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 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.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;
 import 'package:analyzer_experimental/src/generated/element.dart';
 import 'package:analyzer_experimental/src/generated/resolver.dart';
 import 'package:analyzer_experimental/src/generated/engine.dart';
 import 'package:analyzer_experimental/src/generated/java_engine_io.dart';
 import 'package:analyzer_experimental/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer_experimental/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'ast_test.dart' show ASTFactory;
 import 'element_test.dart' show ElementFactory;
 class TypePropagationTest extends ResolverTestCase {
   void fail_functionExpression_asInvocationArgument_functionExpressionInvocation() {
-    String code = EngineTestCase.createSource(["main() {", "  (f(String value)) {} ((v) {", "    v;", "  });", "}"]);
+    String code = EngineTestCase.createSource([
+        "main() {",
+        "  (f(String value)) {} ((v) {",
+        "    v;",
+        "  });",
+        "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;", "  }", "}"]));
+    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();
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "A f(var p) {",
+        "  assert (p is A);",
+        "  return p;",
+        "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;
@@ skipping 17 matching lines @@
     assertNoErrors();
     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;", "  }", "}"]);
+    String code = EngineTestCase.createSource([
+        "f(List<String> p) {",
+        "  for (var e in p) {",
+        "    e;",
+        "  }",
+        "}"]);
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;", "  });", "}"]);
+    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();
     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) {});", "}"]);
+    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();
     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;", "  });", "}"]);
+    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();
     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;", "  });", "}"]);
+    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();
     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) {", "  });", "}"]);
+    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();
     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);
@@ skipping 25 matching lines @@
     LibraryElement library = resolve(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ExpressionStatement statement = body.block.statements[1] as ExpressionStatement;
     PrefixedIdentifier invocation = statement.expression as PrefixedIdentifier;
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "A f(var p) {",
+        "  return (p is A) ? p : null;",
+        "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;", "  }", "}"]));
+    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();
     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) {", "    return p;", "  } else {", "    return null;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "A f(A p) {",
+        "  if (p is Object) {",
+        "    return p;",
+        "  } else {",
+        "    return null;",
+        "  }",
+        "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;", "  }", "}"]));
+    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();
     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;", "}"]));
+    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();
     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;", "}"]));
+    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();
     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();", "  }", "}"]));
+    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]);
     verify([source]);
     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.element);
   }
   void test_is_while() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "A f(var p) {", "  while (p is A) {", "    return p;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "A f(var p) {",
+        "  while (p is A) {",
+        "    return p;",
+        "  }",
+        "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "A f(var p) {",
+        "  return (p is! A) ? null : p;",
+        "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;", "  }", "}"]));
+    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();
     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;", "  }", "}"]));
+    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();
     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;", "}"]));
+    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();
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "A f(var p) {",
+        "  if (p is! A) {",
+        "    return null;",
+        "  }",
+        "  return p;",
+        "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;
@@ skipping 17 matching lines @@
     assertNoErrors();
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  var v = {'0' : 0, 1 : '1', '2' : 2};",
+        "  return v;",
+        "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  var v = {'a' : 0, 'b' : 1, 'c' : 2};",
+        "  return v;",
+        "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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);", "main() {", "  var v = f();", "}"]);
+    String code = EngineTestCase.createSource([
+        "int f() => (42 as Object);",
+        "main() {",
+        "  var v = f();",
+        "}"]);
     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() {", "  var v = f();", "}"]);
+    String code = EngineTestCase.createSource([
+        "f() {",
+        "  if (true) return 0;",
+        "  return 1.0;",
+        "}",
+        "main() {",
+        "  var v = f();",
+        "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.numType);
   }
   void test_propagatedReturnType_function_noReturnTypeName_blockBody_oneReturn() {
-    String code = EngineTestCase.createSource(["f() {", "  var z = 42;", "  return z;", "}", "main() {", "  var v = f();", "}"]);
+    String code = EngineTestCase.createSource([
+        "f() {",
+        "  var z = 42;",
+        "  return z;",
+        "}",
+        "main() {",
+        "  var v = f();",
+        "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
   void test_propagatedReturnType_function_noReturnTypeName_expressionBody() {
     String code = EngineTestCase.createSource(["f() => 42;", "main() {", "  var v = f();", "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
   void test_propagatedReturnType_localFunction() {
     String code = EngineTestCase.createSource(["main() {", "  f() => 42;", "  var v = f();", "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
   void test_query() {
-    Source source = addSource(EngineTestCase.createSource(["import 'dart:html';", "", "main() {", "  var v1 = query('a');", "  var v2 = query('A');", "  var v3 = query('body:active');", "  var v4 = query('button[foo=\"bar\"]');", "  var v5 = query('div.class');", "  var v6 = query('input#id');", "  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];", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'dart:html';",
+        "",
+        "main() {",
+        "  var v1 = query('a');",
+        "  var v2 = query('A');",
+        "  var v3 = query('body:active');",
+        "  var v4 = query('button[foo=\"bar\"]');",
+        "  var v5 = query('div.class');",
+        "  var v6 = query('input#id');",
+        "  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();
     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);
@@ skipping 170 matching lines @@
       });
       _ut.test('test_query', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_query);
       });
     });
   }
 }
 class NonErrorResolverTest extends ResolverTestCase {
   void test_ambiguousExport() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';", "export 'lib2.dart';"]));
+    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();
     verify([source]);
   }
   void test_ambiguousExport_combinators_hide() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';", "export 'lib2.dart' hide B;"]));
+    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();
     verify([source]);
   }
   void test_ambiguousExport_combinators_show() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';", "export 'lib2.dart' show C;"]));
+    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();
     verify([source]);
   }
   void test_argumentDefinitionTestNonParameter_formalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f(var v) {", "  return ?v;", "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_argumentDefinitionTestNonParameter_optionalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f([var v]) {", "  return ?v;", "}"]));
     resolve(source);
     assertErrors([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());", "  }"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "  caller(Function callee) {",
+        "    callee();",
+        "  }",
+        "",
+        "  class CallMeBack {",
+        "    call() => 0;",
+        "  }",
+        "",
+        "  main() {",
+        "    caller(new CallMeBack());",
+        "  }"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_functionParameter_generic() {
-    Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  m(f(K k), K v) {", "    f(v);", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<K> {",
+        "  m(f(K k), K v) {",
+        "    f(v);",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();
     verify([source]);
   }
   void test_argumentTypeNotAssignable_Object_Function() {
-    Source source = addSource(EngineTestCase.createSource(["main() {", "  process(() {});", "}", "process(Object x) {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "main() {",
+        "  process(() {});",
+        "}",
+        "process(Object x) {}"]));
     resolve(source);
     assertNoErrors();
     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');", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef A(int p1, String p2);",
+        "A getA() => null;",
+        "f() {",
+        "  A a = getA();",
+        "  a(1, '2');",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_argumentTypeNotAssignable_typedef_parameter() {
-    Source source = addSource(EngineTestCase.createSource(["typedef A(int p1, String p2);", "f(A a) {", "  a(1, '2');", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef A(int p1, String p2);",
+        "f(A a) {",
+        "  a(1, '2');",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_assignmentToFinal_prefixNegate() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  -x;", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_assignmentToFinals_importWithPrefix() {
-    Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'lib1.dart' as foo;", "main() {", "  foo.x = true;", "}"]));
+    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();
     verify([source]);
   }
   void test_breakWithoutLabelInSwitch() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void m(int i) {", "    switch (i) {", "      case 0:", "        break;", "    }", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void m(int i) {",
+        "    switch (i) {",
+        "      case 0:",
+        "        break;",
+        "    }",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_builtInIdentifierAsType_dynamic() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  dynamic x;", "}"]));
     resolve(source);
     assertNoErrors();
     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;", "    }", "  }", "}"]));
+    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();
     verify([source]);
   }
   void test_caseBlockNotTerminated_lastCase() {
-    Source source = addSource(EngineTestCase.createSource(["f(int p) {", "  switch (p) {", "    case 0:", "      p = p + 1;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(int p) {",
+        "  switch (p) {",
+        "    case 0:",
+        "      p = p + 1;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_caseExpressionTypeImplementsEquals_int() {
-    Source source = addSource(EngineTestCase.createSource(["f(int i) {", "  switch(i) {", "    case(1) : return 1;", "    default: return 0;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(int i) {",
+        "  switch(i) {",
+        "    case(1) : return 1;",
+        "    default: return 0;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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;", "  }", "}"]));
+    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();
     verify([source]);
   }
   void test_caseExpressionTypeImplementsEquals_String() {
-    Source source = addSource(EngineTestCase.createSource(["f(String s) {", "  switch(s) {", "    case('1') : return 1;", "    default: return 0;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(String s) {",
+        "  switch(s) {",
+        "    case('1') : return 1;",
+        "    default: return 0;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_concreteClassWithAbstractMember() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_instance() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  get v => 0;", "}", "class B extends A {", "  get v => 1;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  get v => 0;",
+        "}",
+        "class B extends A {",
+        "  get v => 1;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_conflictingStaticGetterAndInstanceSetter_thisClass() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static get x => 0;", "  static set x(int p) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static get x => 0;",
+        "  static set x(int p) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_conflictingStaticSetterAndInstanceMember_thisClass_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static x() {}", "  static set x(int p) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static x() {}",
+        "  static set x(int p) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_finalInstanceVar() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x = 0;", "  const A();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_mixin() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  a() {}", "}", "class B extends Object with A {", "  const B();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  a() {}",
+        "}",
+        "class B extends Object with A {",
+        "  const B();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "  const A();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_syntheticField() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "  set x(value) {}", "  get x {return 0;}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "  set x(value) {}",
+        "  get x {return 0;}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();
     verify([source]);
   }
   void test_constEval_propertyExtraction_methodStatic_targetType() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "  static m() {}", "}", "const C = A.m;"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "  static m() {}",
+        "}",
+        "const C = A.m;"]));
     resolve(source);
     assertNoErrors();
     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;", "}"]));
+    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();
     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;", "}"]));
+    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();
     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'); }"]));
+    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();
     verify([source]);
   }
   void test_constWithTypeParameters_direct() {
-    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  static const V = const A<int>();", "  const A();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<T> {",
+        "  static const V = const A<int>();",
+        "  const A();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_constWithUndefinedConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A.name();", "}", "f() {", "  return const A.name();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A.name();",
+        "}",
+        "f() {",
+        "  return const A.name();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_constWithUndefinedConstructorDefault() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "f() {", "  return const A();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "}",
+        "f() {",
+        "  return const A();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_defaultValueInFunctionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef F([x]);"]));
     resolve(source);
     assertErrors([]);
     verify([source]);
   }
   void test_duplicateDefinition_emptyName() {
-    Source source = addSource(EngineTestCase.createSource(["Map _globalMap = {", "  'a' : () {},", "  'b' : () {}", "};"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "Map _globalMap = {",
+        "  'a' : () {},",
+        "  'b' : () {}",
+        "};"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_duplicateDefinition_getter() {
     Source source = addSource(EngineTestCase.createSource(["bool get a => true;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
@@ skipping 17 matching lines @@
     assertNoErrors();
     verify([source]);
   }
   void test_extraPositionalArguments_Function() {
     Source source = addSource(EngineTestCase.createSource(["f(Function a) {", "  a(1, 2);", "}"]));
     resolve(source);
     assertNoErrors();
     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);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef A(p1, p2);",
+        "A getA() => null;",
+        "f() {",
+        "  A a = getA();",
+        "  a(1, 2);",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();
     verify([source]);
   }
   void test_fieldInitializedByMultipleInitializers() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  int y;", "  A() : x = 0, y = 0 {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int x;",
+        "  int y;",
+        "  A() : x = 0, y = 0 {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_fieldInitializedInInitializerAndDeclaration_fieldNotFinal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x = 0;", "  A() : x = 1 {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_fieldInitializedInInitializerAndDeclaration_finalFieldNotSet() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x;", "  A() : x = 1 {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_fieldInitializerOutsideConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_fieldInitializerOutsideConstructor_defaultParameters() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A([this.x]) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_fieldInitializerRedirectingConstructor_super() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B extends A {", "  int x;", "  A(this.x) : super();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "class B extends A {",
+        "  int x;",
+        "  A(this.x) : super();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_finalInitializedInDeclarationAndConstructor_initializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A() : x = 1 {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_finalInitializedInDeclarationAndConstructor_initializingFormal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final x;", "  A(this.x) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_finalNotInitialized_atDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x = 0;", "  A() {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_finalNotInitialized_fieldFormal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x = 0;", "  A() {}", "}"]));
     resolve(source);
     assertNoErrors();
     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();
+    verify([source]);
+  }
+  void test_finalNotInitialized_hasNativeClause_hasConstructor() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A native 'something' {",
+        "  final int x;",
+        "  A() {}",
+        "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_finalNotInitialized_hasNativeClause_noConstructor() {
+    Source source = addSource(EngineTestCase.createSource(["class A native 'something' {", "  final int x;", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_finalNotInitialized_initializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x;", "  A() : x = 0 {}", "}"]));
     resolve(source);
     assertNoErrors();
     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();
+    verify([source]);
+  }
   void test_implicitThisReferenceInInitializer_constructorName() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.named() {}", "}", "class B {", "  var v;", "  B() : v = new A.named();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.named() {}",
+        "}",
+        "class B {",
+        "  var v;",
+        "  B() : v = new A.named();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var f;",
+        "}",
+        "class B {",
+        "  var v;",
+        "  B(A a) : v = a.f;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_qualifiedMethodInvocation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  f() {}", "}", "class B {", "  var v;", "  B() : v = new A().f();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  f() {}",
+        "}",
+        "class B {",
+        "  var v;",
+        "  B() : v = new A().f();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_qualifiedPropertyAccess() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var f;", "}", "class B {", "  var v;", "  B() : v = new A().f;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var f;",
+        "}",
+        "class B {",
+        "  var v;",
+        "  B() : v = new A().f;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_staticField_superClass() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static var f;", "}", "class B extends A {", "  var v;", "  B() : v = f;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static var f;",
+        "}",
+        "class B extends A {",
+        "  var v;",
+        "  B() : v = f;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_staticField_thisClass() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f;", "  static var f;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "  A() : v = f;",
+        "  static var f;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_staticGetter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f;", "  static get f => 42;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "  A() : v = f;",
+        "  static get f => 42;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_staticMethod() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f();", "  static f() => 42;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "  A() : v = f();",
+        "  static f() => 42;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_topLevelField() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f;", "}", "var f = 42;"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "  A() : v = f;",
+        "}",
+        "var f = 42;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_topLevelFunction() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f();", "}", "f() => 42;"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "  A() : v = f();",
+        "}",
+        "f() => 42;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_topLevelGetter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f;", "}", "get f => 42;"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "  A() : v = f;",
+        "}",
+        "get f => 42;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_typeVariable() {
     Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  var v;", "  A(p) : v = (p is T);", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_importDuplicatedLibraryName() {
-    Source source = addSource(EngineTestCase.createSource(["library test;", "import 'lib.dart';", "import 'lib.dart';"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "library test;",
+        "import 'lib.dart';",
+        "import 'lib.dart';"]));
     addSource2("/lib.dart", "library lib;");
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_importOfNonLibrary_libraryDeclared() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';"]));
     addSource2("/part.dart", EngineTestCase.createSource(["library lib1;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_importOfNonLibrary_libraryNotDeclared() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';"]));
     addSource2("/part.dart", EngineTestCase.createSource([""]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_inconsistentCaseExpressionTypes() {
-    Source source = addSource(EngineTestCase.createSource(["f(var p) {", "  switch (p) {", "    case 1:", "      break;", "    case 2:", "      break;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(var p) {",
+        "  switch (p) {",
+        "    case 1:",
+        "      break;",
+        "    case 2:",
+        "      break;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_initializingFormalForNonExistantField() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_instanceMemberAccessFromStatic_fromComment() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "  /// [m]", "  static foo() {", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {}",
+        "  /// [m]",
+        "  static foo() {",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidAnnotation_constantVariable() {
     Source source = addSource(EngineTestCase.createSource(["const C = 0;", "@C", "main() {", "}"]));
     resolve(source);
     assertNoErrors();
     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();
     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() {", "}"]));
+    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();
     verify([source]);
   }
   void test_invalidAssignment() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var x;", "  var y;", "  x = y;", "}"]));
     resolve(source);
     assertNoErrors();
     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;", "}"]));
+    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();
     verify([source]);
   }
   void test_invalidAssignment_toDynamic() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var g;", "  g = () => 0;", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidFactoryNameNotAClass() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidMethodOverrideNamedParamType() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m({int a}) {}", "}", "class B implements A {", "  m({int a, int b}) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m({int a}) {}",
+        "}",
+        "class B implements A {",
+        "  m({int a, int b}) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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}) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m({int p : 0}) {}",
+        "}",
+        "class B extends A {",
+        "  m({int p : 0}) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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]) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m([int p = 0]) {}",
+        "}",
+        "class B extends A {",
+        "  m([int p = 0]) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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']) {}", "}"]));
+    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();
     verify([source]);
   }
   void test_invalidOverrideNamed_unorderedNamedParameter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m({a, b}) {}", "}", "class B extends A {", "  m({b, a}) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m({a, b}) {}",
+        "}",
+        "class B extends A {",
+        "  m({b, a}) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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; }", "}"]));
+    Source source = addSource2("/test.dart", EngineTestCase.createSource([
+        "abstract class A {",
+        "  num m();",
+        "}",
+        "class B implements A {",
+        "  int m() { return 1; }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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; }", "}"]));
+    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();
     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; }", "}"]));
+    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();
     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>(); }", "}"]));
+    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();
     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; }", "}"]));
+    Source source = addSource2("/test.dart", EngineTestCase.createSource([
+        "class A {",
+        "  int m() { return 0; }",
+        "}",
+        "class B extends A {",
+        "  int m() { return 1; }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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; }", "}"]));
+    Source source = addSource2("/test.dart", EngineTestCase.createSource([
+        "class A {",
+        "  num m() { return 0; }",
+        "}",
+        "class B extends A {",
+        "  int m() { return 1; }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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; }", "}"]));
+    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();
     verify([source]);
   }
   void test_invalidOverrideReturnType_returnType_void() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void m() {}", "}", "class B extends A {", "  int m() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void m() {}",
+        "}",
+        "class B extends A {",
+        "  int m() {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidReferenceToThis_constructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {", "    var v = this;", "  }", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidReferenceToThis_instanceMethod() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {", "    var v = this;", "  }", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidTypeArgumentInConstList() {
-    Source source = addSource(EngineTestCase.createSource(["class A<E> {", "  m() {", "    return <E>[];", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<E> {",
+        "  m() {",
+        "    return <E>[];",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invalidTypeArgumentInConstMap() {
-    Source source = addSource(EngineTestCase.createSource(["class A<E> {", "  m() {", "    return <String, E>{};", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<E> {",
+        "  m() {",
+        "    return <String, E>{};",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invocationOfNonFunction_dynamic() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var f;", "}", "class B extends A {", "  g() {", "    f();", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var f;",
+        "}",
+        "class B extends A {",
+        "  g() {",
+        "    f();",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invocationOfNonFunction_getter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var g;", "}", "f() {", "  A a;", "  a.g();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var g;",
+        "}",
+        "f() {",
+        "  A a;",
+        "  a.g();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invocationOfNonFunction_localVariable() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var g;", "  g();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invocationOfNonFunction_localVariable_dynamic() {
     Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", "  var v = f;", "  v();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invocationOfNonFunction_localVariable_dynamic2() {
-    Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", "  var v = f;", "  v = 1;", "  v();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {}",
+        "main() {",
+        "  var v = f;",
+        "  v = 1;",
+        "  v();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_invocationOfNonFunction_Object() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  Object v = null;", "  v();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
+  void test_listElementTypeNotAssignable() {
+    Source source = addSource(EngineTestCase.createSource(["var v1 = <int> [42];", "var v2 = const <int> [42];"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_mapKeyTypeNotAssignable() {
+    Source source = addSource(EngineTestCase.createSource(["var v = <String, int > {'a' : 1};"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_memberWithClassName_setter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set A(v) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_instance_sameTypes() {
-    Source source = addSource(EngineTestCase.createSource(["class C {", "  int get x => 0;", "  set x(int v) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class C {",
+        "  int get x => 0;",
+        "  set x(int v) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_instance_unspecifiedGetter() {
     Source source = addSource(EngineTestCase.createSource(["class C {", "  get x => 0;", "  set x(String v) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
@@ skipping 15 matching lines @@
     assertNoErrors();
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedSetter() {
     Source source = addSource(EngineTestCase.createSource(["int get x => 0;", "set x(v) {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_mixinDeclaresConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "}", "class B extends Object with A {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {}",
+        "}",
+        "class B extends Object with A {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_mixinDeclaresConstructor_factory() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() {}", "}", "class B extends Object with A {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  factory A() {}",
+        "}",
+        "class B extends Object with A {}"]));
     resolve(source);
     assertNoErrors();
     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 {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "typedef B = Object with A;",
+        "class C extends Object with B {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_typedef_mixTypedef() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "typedef B = Object with A;", "typedef C = Object with B;"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "typedef B = Object with A;",
+        "typedef C = Object with B;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_multipleSuperInitializers_no() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {", "  B() {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_multipleSuperInitializers_single() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {", "  B() : super() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  B() : super() {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();", "}"]));
+    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();
     verify([source]);
   }
   void test_newWithUndefinedConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.name() {}", "}", "f() {", "  new A.name();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.name() {}",
+        "}",
+        "f() {",
+        "  new A.name();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_newWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "f() {", "  new A();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonBoolExpression_assert_bool() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  assert(true);", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonBoolExpression_assert_functionType() {
-    Source source = addSource(EngineTestCase.createSource(["bool makeAssertion() => true;", "f() {", "  assert(makeAssertion);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "bool makeAssertion() => true;",
+        "f() {",
+        "  assert(makeAssertion);",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstantDefaultValue_function_named() {
     Source source = addSource(EngineTestCase.createSource(["f({x : 2 + 3}) {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
@@ skipping 21 matching lines @@
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstantDefaultValue_method_positional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m([x = 2 + 3]) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstCaseExpression() {
-    Source source = addSource(EngineTestCase.createSource(["f(Type t) {", "  switch (t) {", "    case bool:", "    case int:", "      return true;", "    default:", "      return false;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(Type t) {",
+        "  switch (t) {",
+        "    case bool:",
+        "    case int:",
+        "      return true;",
+        "    default:",
+        "      return false;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_const() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  const {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_notExpressionStatement() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var m = {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstMapAsExpressionStatement_typeArguments() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  <String, int> {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
     assertNoErrors();
     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;", "}"]));
+    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]);
     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;", "}"]));
+    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();
   }
   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;", "}"]));
+    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();
     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;", "}"]));
+    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();
     verify([source]);
   }
   void test_nonConstValueInInitializer_field() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  final int a;", "  const A() : a = 5;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final int a;",
+        "  const A() : a = 5;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstValueInInitializer_redirecting() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A.named(p);", "  const A() : this.named(42);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A.named(p);",
+        "  const A() : this.named(42);",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstValueInInitializer_super() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A(p);", "}", "class B extends A {", "  const B() : super(42);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(p);",
+        "}",
+        "class B extends A {",
+        "  const B() : super(42);",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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;", "}"]));
+    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();
     verify([source]);
   }
   void test_nonGenerativeConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.named() {}", "  factory A() {}", "}", "class B extends A {", "  B() : super.named();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.named() {}",
+        "  factory A() {}",
+        "}",
+        "class B extends A {",
+        "  B() : super.named();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonTypeInCatchClause_isClass() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  try {", "  } on String catch (e) {", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  try {",
+        "  } on String catch (e) {",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonTypeInCatchClause_isFunctionTypeAlias() {
-    Source source = addSource(EngineTestCase.createSource(["typedef F();", "f() {", "  try {", "  } on F catch (e) {", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef F();",
+        "f() {",
+        "  try {",
+        "  } on F catch (e) {",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonTypeInCatchClause_isTypeVariable() {
-    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  f() {", "    try {", "    } on T catch (e) {", "    }", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<T> {",
+        "  f() {",
+        "    try {",
+        "    } on T catch (e) {",
+        "    }",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonTypeInCatchClause_noType() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  try {", "  } catch (e) {", "  }", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
@@ skipping 34 matching lines @@
     verify([source]);
   }
   void test_optionalParameterInOperator_required() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator +(p) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers() {
     addSource2("/lib.dart", "library lib;");
-    Source source = addSource(EngineTestCase.createSource(["import '/lib.dart' as p;", "typedef P();", "p2() {}", "var p3;", "class p4 {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "import '/lib.dart' as p;",
+        "typedef P();",
+        "p2() {}",
+        "var p3;",
+        "class p4 {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_recursiveConstructorRedirect() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.a() : this.b();", "  A.b() : this.c();", "  A.c() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.a() : this.b();",
+        "  A.b() : this.c();",
+        "  A.c() {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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() {}", "}"]));
+    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();
     verify([source]);
   }
   void test_redirectToInvalidFunctionType() {
-    Source source = addSource(EngineTestCase.createSource(["class A implements B {", "  A(int p) {}", "}", "class B {", "  B(int p) = A;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A implements B {",
+        "  A(int p) {}",
+        "}",
+        "class B {",
+        "  factory B(int p) = A;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_redirectToNonConstConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A.a();", "  const factory A.b() = A.a;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A.a();",
+        "  const factory A.b() = A.a;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_constructorName() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.x() {}", "}", "f() {", "  var x = new A.x();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.x() {}",
+        "}",
+        "f() {",
+        "  var x = new A.x();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_methodName() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  x() {}", "}", "f(A a) {", "  var x = a.x();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  x() {}",
+        "}",
+        "f(A a) {",
+        "  var x = a.x();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_propertyName() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var x;", "}", "f(A a) {", "  var x = a.x;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var x;",
+        "}",
+        "f(A a) {",
+        "  var x = a.x;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_rethrowOutsideCatch() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void m() {", "    try {} catch (e) {rethrow;}", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void m() {",
+        "    try {} catch (e) {rethrow;}",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_returnInGenerativeConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() { return; }", "}"]));
     resolve(source);
     assertNoErrors();
     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;", "      }", "    }", "  }", "}"]));
+    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();
     verify([source]);
   }
   void test_returnOfInvalidType_dynamicAsTypeArgument() {
-    Source source = addSource(EngineTestCase.createSource(["class I<T> {", "  factory I() => new A<T>();", "}", "class A<T> implements I {", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class I<T> {",
+        "  factory I() => new A<T>();",
+        "}",
+        "class A<T> implements I {",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_returnOfInvalidType_subtype() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {}", "A f(B b) { return b; }"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {}",
+        "A f(B b) { return b; }"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_returnOfInvalidType_supertype() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {}", "B f(A a) { return a; }"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {}",
+        "B f(A a) { return a; }"]));
     resolve(source);
     assertNoErrors();
     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() {}", ""]));
+    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();
     verify([source]);
   }
   void test_returnWithoutValue_noReturnType() {
     Source source = addSource(EngineTestCase.createSource(["f() { return; }"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_returnWithoutValue_void() {
     Source source = addSource(EngineTestCase.createSource(["void f() { return; }"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_staticAccessToInstanceMember_annotation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A.name();", "}", "@A.name()", "main() {", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A.name();",
+        "}",
+        "@A.name()",
+        "main() {",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_staticAccessToInstanceMember_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static m() {}", "}", "main() {", "  A.m;", "  A.m();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static m() {}",
+        "}",
+        "main() {",
+        "  A.m;",
+        "  A.m();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_staticAccessToInstanceMember_propertyAccess_field() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static var f;", "}", "main() {", "  A.f;", "  A.f = 1;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static var f;",
+        "}",
+        "main() {",
+        "  A.f;",
+        "  A.f = 1;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static get f => 42;",
+        "  static set f(x) {}",
+        "}",
+        "main() {",
+        "  A.f;",
+        "  A.f = 1;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();", "  }", "}"]));
+    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();
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_returnClass_withTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef B A();", "class B {", "  A a;", "}"]));
     resolve(source);
     assertNoErrors();
     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>(); }"]));
+    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();
     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>(); }"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {}",
+        "class G<E extends A> {}",
+        "f() { return new G<B>(); }"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_typeArgumentList_0() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A>{}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_typeArgumentList_1() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A<A>>{}"]));
     resolve(source);
     assertNoErrors();
     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();
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_explicit_named() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.named() {}", "}", "class B extends A {", "  B() : super.named();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.named() {}",
+        "}",
+        "class B extends A {",
+        "  B() : super.named();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_explicit_unnamed() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B extends A {", "  B() : super();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "class B extends A {",
+        "  B() : super();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_hasOptionalParameters() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A([p]) {}", "}", "class B extends A {", "  B();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A([p]) {}",
+        "}",
+        "class B extends A {",
+        "  B();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_implicit() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B extends A {", "  B();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "class B extends A {",
+        "  B();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_implicit_typedef() {
-    Source source = addSource(EngineTestCase.createSource(["class M {}", "typedef A = Object with M;", "class B extends A {", "  B();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class M {}",
+        "typedef A = Object with M;",
+        "class B extends A {",
+        "  B();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class Foo {",
+        "  Foo.ctor();",
+        "}",
+        "class Bar extends Foo {",
+        "  Bar() : this.ctor();",
+        "  Bar.ctor() : super.ctor();",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedGetter_noSuchMethod_getter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  noSuchMethod(invocation) {}", "}", "f() {", "  (new A()).g;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  noSuchMethod(invocation) {}",
+        "}",
+        "f() {",
+        "  (new A()).g;",
+        "}"]));
     resolve(source);
     assertNoErrors();
   }
   void test_undefinedGetter_noSuchMethod_getter2() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  noSuchMethod(invocation) {}", "}", "class B {", "  A a = new A();", "  m() {", "    a.g;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  noSuchMethod(invocation) {}",
+        "}",
+        "class B {",
+        "  A a = new A();",
+        "  m() {",
+        "    a.g;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
   }
   void test_undefinedGetter_typeSubstitution() {
-    Source source = addSource(EngineTestCase.createSource(["class A<E> {", "  E element;", "}", "class B extends A<List> {", "  m() {", "    element.last;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<E> {",
+        "  E element;",
+        "}",
+        "class B extends A<List> {",
+        "  m() {",
+        "    element.last;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();
     verify([source]);
   }
   void test_undefinedIdentifier_noSuchMethod() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  noSuchMethod(invocation) {}", "  f() {", "    var v = a;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  noSuchMethod(invocation) {}",
+        "  f() {",
+        "    var v = a;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
   }
   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();
     verify([source]);
   }
   void test_undefinedMethod_functionExpression_callMethod() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  (() => null).call();", "}"]));
     resolve(source);
     assertNoErrors();
   }
   void test_undefinedMethod_functionExpression_directCall() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  (() => null)();", "}"]));
     resolve(source);
     assertNoErrors();
   }
   void test_undefinedMethod_noSuchMethod() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  noSuchMethod(invocation) {}", "}", "f() {", "  (new A()).m();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  noSuchMethod(invocation) {}",
+        "}",
+        "f() {",
+        "  (new A()).m();",
+        "}"]));
     resolve(source);
     assertNoErrors();
   }
   void test_undefinedOperator_index() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  operator [](a) {}", "  operator []=(a, b) {}", "}", "f(A a) {", "  a[0];", "  a[0] = 1;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  operator [](a) {}",
+        "  operator []=(a, b) {}",
+        "}",
+        "f(A a) {",
+        "  a[0];",
+        "  a[0] = 1;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedOperator_tilde() {
     Source source = addSource(EngineTestCase.createSource(["const A = 3;", "const B = ~((1 << A) - 1);"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedSetter_noSuchMethod() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  noSuchMethod(invocation) {}", "}", "f() {", "  (new A()).s = 1;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  noSuchMethod(invocation) {}",
+        "}",
+        "f() {",
+        "  (new A()).s = 1;",
+        "}"]));
     resolve(source);
     assertNoErrors();
   }
   void test_undefinedSuperMethod_field() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var m;", "}", "class B extends A {", "  f() {", "    super.m();", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var m;",
+        "}",
+        "class B extends A {",
+        "  f() {",
+        "    super.m();",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedSuperMethod_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "}", "class B extends A {", "  f() {", "    super.m();", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {}",
+        "}",
+        "class B extends A {",
+        "  f() {",
+        "    super.m();",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_wrongNumberOfParametersForOperator_index() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator []=(a, b) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
@@ skipping 253 matching lines @@
         runJUnitTest(__test, __test.test_finalInitializedInDeclarationAndConstructor_initializingFormal);
       });
       _ut.test('test_finalNotInitialized_atDeclaration', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_finalNotInitialized_atDeclaration);
       });
       _ut.test('test_finalNotInitialized_fieldFormal', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_finalNotInitialized_fieldFormal);
       });
+      _ut.test('test_finalNotInitialized_functionTypedFieldFormal', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_finalNotInitialized_functionTypedFieldFormal);
+      });
+      _ut.test('test_finalNotInitialized_hasNativeClause_hasConstructor', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_finalNotInitialized_hasNativeClause_hasConstructor);
+      });
+      _ut.test('test_finalNotInitialized_hasNativeClause_noConstructor', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_finalNotInitialized_hasNativeClause_noConstructor);
+      });
       _ut.test('test_finalNotInitialized_initializer', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_finalNotInitialized_initializer);
       });
+      _ut.test('test_finalNotInitialized_redirectingConstructor', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_finalNotInitialized_redirectingConstructor);
+      });
       _ut.test('test_implicitThisReferenceInInitializer_constructorName', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_constructorName);
       });
       _ut.test('test_implicitThisReferenceInInitializer_prefixedIdentifier', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_prefixedIdentifier);
       });
       _ut.test('test_implicitThisReferenceInInitializer_qualifiedMethodInvocation', () {
         final __test = new NonErrorResolverTest();
@@ skipping 172 matching lines @@
         runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable);
       });
       _ut.test('test_invocationOfNonFunction_localVariable_dynamic', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable_dynamic);
       });
       _ut.test('test_invocationOfNonFunction_localVariable_dynamic2', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable_dynamic2);
       });
+      _ut.test('test_listElementTypeNotAssignable', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_listElementTypeNotAssignable);
+      });
+      _ut.test('test_mapKeyTypeNotAssignable', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_mapKeyTypeNotAssignable);
+      });
       _ut.test('test_memberWithClassName_setter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_memberWithClassName_setter);
       });
       _ut.test('test_misMatchedGetterAndSetterTypes_instance_sameTypes', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_misMatchedGetterAndSetterTypes_instance_sameTypes);
       });
       _ut.test('test_misMatchedGetterAndSetterTypes_instance_unspecifiedGetter', () {
         final __test = new NonErrorResolverTest();
@@ skipping 525 matching lines @@
     assertErrors([StaticTypeWarningCode.INACCESSIBLE_SETTER]);
     verify([source]);
   }
   void fail_redirectWithInvalidTypeParameters() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.REDIRECT_WITH_INVALID_TYPE_PARAMETERS]);
     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 {", "}"]));
+    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]);
     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 {}"]));
+    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]);
     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 {}"]));
+    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]);
     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;", "}"]));
+    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]);
     verify([source]);
   }
   void test_invalidAssignment_instanceVariable() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "}", "f() {", "  A a;", "  a.x = '0';", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int x;",
+        "}",
+        "f() {",
+        "  A a;",
+        "  a.x = '0';",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_invalidAssignment_staticVariable() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "}", "f() {", "  A.x = '0';", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static int x;",
+        "}",
+        "f() {",
+        "  A.x = '0';",
+        "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
   void test_invalidAssignment_topLevelVariableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["int x = 'string';"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_invocationOfNonFunction_class() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  void m() {", "    A();", "  }", "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_invocationOfNonFunction_ordinaryInvocation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "}", "class B {", "  m() {", "    A.x();", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static int x;",
+        "}",
+        "class B {",
+        "  m() {",
+        "    A.x();",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
   void test_invocationOfNonFunction_staticInvocation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static int get g => 0;", "  f() {", "    A.g();", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static int get g => 0;",
+        "  f() {",
+        "    A.g();",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
   void test_nonBoolCondition_conditional() {
     Source source = addSource(EngineTestCase.createSource(["f() { return 3 ? 2 : 1; }"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
   void test_nonBoolCondition_do() {
@@ skipping 38 matching lines @@
     assertErrors([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]);
     verify([source]);
   }
   void test_returnOfInvalidType_expressionFunctionBody_localFunction() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  String m() {", "    int f() => '0';", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  String m() {",
+        "    int f() => '0';",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_returnOfInvalidType_expressionFunctionBody_void() {
     Source source = addSource(EngineTestCase.createSource(["void f() => 42;"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_returnOfInvalidType_getter() {
     Source source = addSource(EngineTestCase.createSource(["int get g { return '0'; }"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_returnOfInvalidType_localFunction() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  String m() {", "    int f() { return '0'; }", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  String m() {",
+        "    int f() { return '0'; }",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_returnOfInvalidType_void() {
     Source source = addSource(EngineTestCase.createSource(["void f() { return 42; }"]));
     resolve(source);
     assertErrors([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;"]));
+    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]);
     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>{}"]));
+    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]);
     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) {}", "}"]));
+    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]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_functionReturnType() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "G<B> f() {}"]));
+    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]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_functionTypeAlias() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "typedef G<B> f();"]));
+    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]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_functionTypedFormalParameter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "f(G<B> h()) {}"]));
+    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]);
     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>{}"]));
+    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]);
     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>;"]));
+    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]);
     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() {}", "}"]));
+    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]);
     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>(); }"]));
+    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]);
     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>(); }"]));
+    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]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_parameter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "f(G<B> g) {}"]));
+    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]);
     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;"]));
+    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]);
     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>> {}"]));
+    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]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_variableDeclaration() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "G<B> g;"]));
+    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]);
     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>{}"]));
+    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]);
     verify([source]);
   }
   void test_undefinedFunction() {
     Source source = addSource(EngineTestCase.createSource(["void f() {", "  g();", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_FUNCTION]);
   }
   void test_undefinedGetter() {
     Source source = addSource(EngineTestCase.createSource(["class T {}", "f(T e) { return e.m; }"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
   void test_undefinedGetter_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "var a = A.B;"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
   void test_undefinedMethod() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  void m() {", "    n();", "  }", "}"]));
     resolve(source);
     assertErrors([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();", "  }", "}"]));
+    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]);
   }
   void test_undefinedOperator_indexBoth() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0]++;", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_indexGetter() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0];", "}"]));
@@ skipping 14 matching lines @@
     Source source = addSource(EngineTestCase.createSource(["class T {}", "f(T e1) { e1.m = 0; }"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_SETTER]);
   }
   void test_undefinedSetter_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f() { A.B = 0;}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_SETTER]);
   }
   void test_undefinedSuperMethod() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {", "  m() { return super.m(); }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  m() { return super.m(); }",
+        "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_SUPER_METHOD]);
   }
   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]);
     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]);
     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>;", "}"]));
+    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]);
     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>;", "}"]));
+    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]);
     verify([source]);
   }
   static dartSuite() {
     _ut.group('StaticTypeWarningCodeTest', () {
       _ut.test('test_inconsistentMethodInheritance_paramCount', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_inconsistentMethodInheritance_paramCount);
       });
@@ skipping 299 matching lines @@
     assertErrors([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]);
     verify([source]);
   }
   void test_deadCode_deadCatch_catchFollowingCatch() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "f() {", "  try {} catch (e) {} catch (e) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "f() {",
+        "  try {} catch (e) {} catch (e) {}",
+        "}"]));
     resolve(source);
     assertErrors([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) {}}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "f() {",
+        "  try {} catch (e) {} catch (e) {if(false) {}}",
+        "}"]));
     resolve(source);
     assertErrors([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) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  try {} on Object catch (e) {} catch (e) {}",
+        "}"]));
     resolve(source);
     assertErrors([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) {}}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  try {} on Object catch (e) {} catch (e) {if(false) {}}",
+        "}"]));
     resolve(source);
     assertErrors([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) {}", "}"]));
+    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]);
     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) {}}", "}"]));
+    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]);
     verify([source]);
   }
   void test_deadCode_deadOperandLHS_and() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = false && false;", "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_deadCode_deadOperandLHS_or() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = true || true;", "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_deadCode_statementAfterReturn_function() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var one = 1;", "  return;", "  var two = 2;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  var one = 1;",
+        "  return;",
+        "  var two = 2;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(bool b) {",
+        "  if(b) {",
+        "    var one = 1;",
+        "    return;",
+        "    var two = 2;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {",
+        "    var one = 1;",
+        "    return;",
+        "    var two = 2;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_deadCode_statementAfterReturn_nested() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var one = 1;", "  return;", "  if(false) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  var one = 1;",
+        "  return;",
+        "  if(false) {}",
+        "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  var one = 1;",
+        "  return;",
+        "  var two = 2;",
+        "  return;",
+        "  var three = 3;",
+        "}"]));
     resolve(source);
     assertErrors([HintCode.DEAD_CODE]);
     verify([source]);
   }
   static dartSuite() {
     _ut.group('HintCodeTest', () {
       _ut.test('test_deadCode_deadBlock_conditionalElse', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalElse);
       });
@@ skipping 647 matching lines @@
     InterfaceType doubleType = classElement("double", numType, []).type;
     InterfaceType functionType = classElement("Function", objectType, []).type;
     InterfaceType intType = classElement("int", numType, []).type;
     InterfaceType listType = classElement("List", objectType, ["E"]).type;
     InterfaceType mapType = classElement("Map", objectType, ["K", "V"]).type;
     InterfaceType stackTraceType = classElement("StackTrace", objectType, []).type;
     InterfaceType stringType = classElement("String", objectType, []).type;
     InterfaceType symbolType = classElement("Symbol", objectType, []).type;
     InterfaceType typeType = classElement("Type", objectType, []).type;
     CompilationUnitElementImpl unit = new CompilationUnitElementImpl("lib.dart");
-    unit.types = <ClassElement> [boolType.element, doubleType.element, functionType.element, intType.element, listType.element, mapType.element, objectType.element, stackTraceType.element, stringType.element, symbolType.element, typeType.element];
+    unit.types = <ClassElement> [
+        boolType.element,
+        doubleType.element,
+        functionType.element,
+        intType.element,
+        listType.element,
+        mapType.element,
+        objectType.element,
+        stackTraceType.element,
+        stringType.element,
+        symbolType.element,
+        typeType.element];
     LibraryElementImpl library = new LibraryElementImpl(new AnalysisContextImpl(), ASTFactory.libraryIdentifier2(["lib"]));
     library.definingCompilationUnit = unit;
     TypeProviderImpl provider = new TypeProviderImpl(library);
     JUnitTestCase.assertSame(boolType, provider.boolType);
     JUnitTestCase.assertNotNull(provider.bottomType);
     JUnitTestCase.assertSame(doubleType, provider.doubleType);
     JUnitTestCase.assertNotNull(provider.dynamicType);
     JUnitTestCase.assertSame(functionType, provider.functionType);
     JUnitTestCase.assertSame(intType, provider.intType);
     JUnitTestCase.assertSame(listType, provider.listType);
@@ skipping 484 matching lines @@
   }
 }
 class CompileTimeErrorCodeTest extends ResolverTestCase {
   void fail_compileTimeConstantRaisesException() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION]);
     verify([source]);
   }
   void fail_constEvalThrowsException() {
-    Source source = addSource(EngineTestCase.createSource(["class C {", "  const C();", "}", "f() { return const C(); }"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class C {",
+        "  const C();",
+        "}",
+        "f() { return const C(); }"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION]);
     verify([source]);
   }
   void fail_extendsOrImplementsDisallowedClass_extends_null() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Null {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void fail_extendsOrImplementsDisallowedClass_implements_null() {
     Source source = addSource(EngineTestCase.createSource(["class A implements Null {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void fail_mixinDeclaresConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B extends Object mixin A {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "class B extends Object mixin A {}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void fail_objectCannotExtendAnotherClass() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.OBJECT_CANNOT_EXTEND_ANOTHER_CLASS]);
     verify([source]);
   }
   void fail_recursiveCompileTimeConstant() {
     Source source = addSource(EngineTestCase.createSource(["const x = y + 1;", "const y = x + 1;"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]);
     verify([source]);
   }
-  void fail_recursiveFunctionTypeAlias_direct() {
-    Source source = addSource(EngineTestCase.createSource(["typedef F(F f);"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_FUNCTION_TYPE_ALIAS]);
-    verify([source]);
-  }
-  void fail_recursiveFunctionTypeAlias_indirect() {
-    Source source = addSource(EngineTestCase.createSource(["typedef F(G g);", "typedef G(F f);"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_FUNCTION_TYPE_ALIAS]);
-    verify([source]);
-  }
-  void fail_reservedWordAsIdentifier() {
-    Source source = addSource(EngineTestCase.createSource(["int class = 2;"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.RESERVED_WORD_AS_IDENTIFIER]);
-    verify([source]);
-  }
-  void fail_staticTopLevelFunction_topLevel() {
-    Source source = addSource(EngineTestCase.createSource(["static f() {}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.STATIC_TOP_LEVEL_FUNCTION]);
-    verify([source]);
-  }
-  void fail_staticTopLevelVariable() {
-    Source source = addSource(EngineTestCase.createSource(["static int x;"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.STATIC_TOP_LEVEL_VARIABLE]);
-    verify([source]);
-  }
   void fail_superInitializerInObject() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.SUPER_INITIALIZER_IN_OBJECT]);
     verify([source]);
   }
-  void fail_uninitializedFinalField() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  final int i;", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.UNINITIALIZED_FINAL_FIELD]);
-    verify([source]);
-  }
   void test_ambiguousExport() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';", "export 'lib2.dart';"]));
+    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]);
     verify([source]);
   }
   void test_ambiguousImport_as() {
-    Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "f(p) {p as N;}"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_extends() {
-    Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "class A extends N {}"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT, CompileTimeErrorCode.EXTENDS_NON_CLASS]);
+    assertErrors([
+        CompileTimeErrorCode.AMBIGUOUS_IMPORT,
+        CompileTimeErrorCode.EXTENDS_NON_CLASS]);
   }
   void test_ambiguousImport_function() {
-    Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "g() { return f(); }"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT, StaticTypeWarningCode.UNDEFINED_FUNCTION]);
+    assertErrors([
+        CompileTimeErrorCode.AMBIGUOUS_IMPORT,
+        StaticTypeWarningCode.UNDEFINED_FUNCTION]);
   }
   void test_ambiguousImport_implements() {
-    Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "class A implements N {}"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT, CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
+    assertErrors([
+        CompileTimeErrorCode.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();}"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_is() {
-    Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "f(p) {p is N;}"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_qualifier() {
-    Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "g() { N.FOO; }"]));
+    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([CompileTimeErrorCode.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>();}"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_varRead() {
-    Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "f() { g(v); }", "g(p) {}"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
   }
   void test_ambiguousImport_varWrite() {
-    Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "f() { v = 0; }"]));
+    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([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
   }
   void test_argumentDefinitionTestNonParameter() {
     Source source = addSource(EngineTestCase.createSource(["f() {", " var v = 0;", " return ?v;", "}"]));
     resolve(source);
-    assertErrors([ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST, CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER]);
+    assertErrors([
+        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]);
+    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]);
     verify([source]);
   }
   void test_builtInIdentifierAsType() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  typedef x;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, StaticWarningCode.UNDEFINED_CLASS]);
+    assertErrors([
+        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]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypedefName_functionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef bool as();"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypeVariableName() {
     Source source = addSource(EngineTestCase.createSource(["class A<as> {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_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;", "  }", "}", "", "f(var a) {", "  switch(a) {", "    case(const IntWrapper(1)) : return 1;", "    default: return 0;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class IntWrapper {",
+        "  final int value;",
+        "  const IntWrapper(this.value);",
+        "  bool operator ==(IntWrapper x) {",
+        "    return value == x.value;",
+        "  }",
+        "}",
+        "",
+        "f(var a) {",
+        "  switch(a) {",
+        "    case(const IntWrapper(1)) : return 1;",
+        "    default: return 0;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     verify([source]);
   }
   void test_conflictingGetterAndMethod_field_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int m;", "}", "class B extends A {", "  m() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int m;",
+        "}",
+        "class B extends A {",
+        "  m() {}",
+        "}"]));
     resolve(source);
     assertErrors([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() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  get m => 0;",
+        "}",
+        "class B extends A {",
+        "  m() {}",
+        "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {}",
+        "}",
+        "class B extends A {",
+        "  int m;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {}",
+        "}",
+        "class B extends A {",
+        "  get m => 0;",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_mixin() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var a;", "}", "class B extends Object with A {", "  const B();", "}"]));
+    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]);
     verify([source]);
   }
   void test_constConstructorWithNonFinalField_super() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var a;", "}", "class B extends A {", "  const B();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var a;",
+        "}",
+        "class B extends A {",
+        "  const B();",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
     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]);
     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]);
     verify([source]);
   }
   void test_constEval_propertyExtraction_methodInstance() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "  m() {}", "}", "final a = const A();", "const C = a.m;"]));
+    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]);
     verify([source]);
   }
   void test_constEval_propertyExtraction_methodStatic_targetInstance() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "  static m() {}", "}", "final a = const A();", "const C = a.m;"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "  static m() {}",
+        "}",
+        "final a = const A();",
+        "const C = a.m;"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_constEvalThrowsException_unaryBitNot_null() {
     Source source = addSource("const C = ~null;");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors([
+        CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
+        StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_constEvalThrowsException_unaryNegated_null() {
     Source source = addSource("const C = -null;");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors([
+        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]);
     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([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL, HintCode.DEAD_CODE]);
+    assertErrors([
+        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();", "}"]));
+    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]);
     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();", "}"]));
+    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]);
     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]);
+    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]);
     verify([source]);
   }
   void test_constFormalParameter_simpleFormalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f(const x) {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
@@ skipping 17 matching lines @@
     assertErrors([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]);
     verify([source]);
   }
   void test_constWithInvalidTypeParameters() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "f() { return const A<A>(); }"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "}",
+        "f() { return const A<A>(); }"]));
     resolve(source);
     assertErrors([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>();", "}"]));
+    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]);
     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>();", "}"]));
+    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]);
     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); }"]));
+    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]);
     verify([source]);
   }
   void test_constWithNonConstantArgument_annotation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A(int p);", "}", "var v = 42;", "@A(v)", "main() {", "}"]));
+    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]);
     verify([source]);
   }
   void test_constWithNonConstantArgument_instanceCreation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A(a);", "}", "f(p) { return const A(p); }"]));
+    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]);
     verify([source]);
   }
   void test_constWithNonType() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "f() {", "  return const A();", "}"]));
     resolve(source);
     assertErrors([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();", "}"]));
+    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]);
     verify([source1]);
   }
   void test_constWithTypeParameters_direct() {
-    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  static const V = const A<T>();", "  const A();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<T> {",
+        "  static const V = const A<T>();",
+        "  const A();",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
+    assertErrors([
+        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();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<T> {",
+        "  static const V = const A<List<T>>();",
+        "  const A();",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
+    assertErrors([
+        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();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "}",
+        "f() {",
+        "  return const A.noSuchConstructor();",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);
   }
   void test_constWithUndefinedConstructorDefault() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A.name();", "}", "f() {", "  return const A();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A.name();",
+        "}",
+        "f() {",
+        "  return const A();",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_duplicateConstructorName_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A.a() {}", "  A.a() {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME, CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME]);
+    assertErrors([
+        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([CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT, CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT]);
+    assertErrors([
+        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([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors([
+        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]);
     verify([librarySource, sourceA, sourceB]);
   }
   void test_duplicateDefinition_classMembers_fields() {
     Source librarySource = addSource(EngineTestCase.createSource(["class A {", "  int a;", "  int a;", "}"]));
     resolve(librarySource);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors([
+        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource]);
   }
   void test_duplicateDefinition_classMembers_fields_oneStatic() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  static int x;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors([
+        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([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors([
+        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource]);
   }
   void test_duplicateDefinition_localFields() {
-    Source librarySource = addSource(EngineTestCase.createSource(["class A {", "  m() {", "    int a;", "    int a;", "  }", "}"]));
+    Source librarySource = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {",
+        "    int a;",
+        "    int a;",
+        "  }",
+        "}"]));
     resolve(librarySource);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors([
+        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource]);
   }
   void test_duplicateDefinition_parameterWithFunctionName_local() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  f(f) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors([
+        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_parameterWithFunctionName_topLevel() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  f(f) {}", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors([
+        CompileTimeErrorCode.DUPLICATE_DEFINITION,
+        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinitionInheritance_instanceMethod_staticMethod() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  x() {}", "}", "class B extends A {", "  static x() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  x() {}",
+        "}",
+        "class B extends A {",
+        "  static x() {}",
+        "}"]));
     resolve(source);
     assertErrors([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() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A {",
+        "  x();",
+        "}",
+        "abstract class B extends A {",
+        "  static x() {}",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_exportInternalLibrary() {
     Source source = addSource(EngineTestCase.createSource(["export 'dart:_interceptors';"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_extendsNonClass_class() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B extends A {}"]));
     resolve(source);
     assertErrors([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]);
+    verify([source]);
+  }
   void test_extendsOrImplementsDisallowedClass_extends_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A extends bool {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    assertErrors([
+        CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_extends_double() {
     Source source = addSource(EngineTestCase.createSource(["class A extends double {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    assertErrors([
+        CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_extends_int() {
     Source source = addSource(EngineTestCase.createSource(["class A extends int {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    assertErrors([
+        CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_extends_num() {
     Source source = addSource(EngineTestCase.createSource(["class A extends num {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    assertErrors([
+        CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_extends_String() {
     Source source = addSource(EngineTestCase.createSource(["class A extends String {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
+    assertErrors([
+        CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_implements_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A implements bool {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_implements_double() {
     Source source = addSource(EngineTestCase.createSource(["class A implements double {}"]));
@@ skipping 13 matching lines @@
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_implements_String() {
     Source source = addSource(EngineTestCase.createSource(["class A implements String {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_extraPositionalArguments_const() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "main() {", "  const A(0);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "}",
+        "main() {",
+        "  const A(0);",
+        "}"]));
     resolve(source);
     assertErrors([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]);
+    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]);
     verify([source]);
   }
   void test_fieldInitializedByMultipleInitializers_multipleInits() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A() : x = 0, x = 1, x = 2 {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int x;",
+        "  A() : x = 0, x = 1, x = 2 {}",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
+    assertErrors([
+        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 {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int x;",
+        "  int y;",
+        "  A() : x = 0, x = 1, y = 0, y = 1 {}",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS, CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
+    assertErrors([
+        CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS,
+        CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
   void test_fieldInitializedInInitializerAndDeclaration_final() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x = 0;", "  A() : x = 1 {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final int x = 0;",
+        "  A() : x = 1 {}",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
     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]);
     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]);
     verify([source]);
   }
   void test_fieldInitializerNotAssignable() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x;", "  const A() : x = '';", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final int x;",
+        "  const A() : x = '';",
+        "}"]));
     resolve(source);
     assertErrors([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([ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
+    assertErrors([
+        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]);
     verify([source]);
   }
   void test_fieldInitializerRedirectingConstructor_afterRedirection() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A.named() {}", "  A() : this.named(), x = 42;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int x;",
+        "  A.named() {}",
+        "  A() : this.named(), x = 42;",
+        "}"]));
     resolve(source);
     assertErrors([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();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int x;",
+        "  A.named() {}",
+        "  A() : x = 42, this.named();",
+        "}"]));
     resolve(source);
     assertErrors([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();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int x;",
+        "  A.named() {}",
+        "  A(this.x) : this.named();",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
     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.
    *
@@ skipping 36 matching lines @@
   }
   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]);
     verify([source]);
   }
   void test_getterAndMethodWithSameName() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  x(y) {}", "  get x => 0;", "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME, CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME]);
+    assertErrors([
+        CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME,
+        CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME]);
     verify([source]);
   }
   void test_implementsDynamic() {
     Source source = addSource(EngineTestCase.createSource(["class A implements dynamic {}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     verify([source]);
   }
   void test_implementsRepeated() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B implements A, A {}"]));
     resolve(source);
     assertErrors([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 {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {} class C{}",
+        "class B implements A, A, A, A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPLEMENTS_REPEATED, CompileTimeErrorCode.IMPLEMENTS_REPEATED, CompileTimeErrorCode.IMPLEMENTS_REPEATED]);
+    assertErrors([
+        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]);
+    verify([source]);
+  }
+  void test_implementsSuperClass_Object() {
+    Source source = addSource(EngineTestCase.createSource(["class A implements Object {}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_field() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f;", "  var f;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "  A() : v = f;",
+        "  var f;",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_invocation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f();", "  f() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "  A() : v = f();",
+        "  f() {}",
+        "}"]));
+    resolve(source);
+    assertErrors([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]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_redirectingConstructorInvocation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A(p) {}", "  A.named() : this(f);", "  var f;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A(p) {}",
+        "  A.named() : this(f);",
+        "  var f;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    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]);
     verify([source]);
   }
   void test_importInternalLibrary() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:_interceptors';"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY]);
     verify([source]);
   }
   void test_importInternalLibrary_collection() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:_collection-dev';"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY]);
     verify([source]);
   }
   void test_importOfNonLibrary() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';"]));
     addSource2("/part.dart", EngineTestCase.createSource(["part of lib;"]));
     resolve(source);
     assertErrors([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;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(var p) {",
+        "  switch (p) {",
+        "    case 1:",
+        "      break;",
+        "    case 'a':",
+        "      break;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(var p) {",
+        "  switch (p) {",
+        "    case 1:",
+        "      break;",
+        "    case 'a':",
+        "      break;",
+        "    case 'b':",
+        "      break;",
+        "  }",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES, CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES]);
+    assertErrors([
+        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]);
   }
   void test_initializerForStaticField() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "  A() : x = 0 {}", "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_initializingFormalForNonExistantField_notInEnclosingClass() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "int x;", "}", "class B extends A {", "  B(this.x) {}", "}"]));
+    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]);
     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]);
     verify([source]);
   }
   void test_initializingFormalForNonExistantField_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  static int x;", "  A([this.x]) {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD]);
     verify([source]);
   }
   void test_instanceMemberAccessFromStatic_field() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int f;", "  static foo() {", "    f;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int f;",
+        "  static foo() {",
+        "    f;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  get g => null;",
+        "  static foo() {",
+        "    g;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
     verify([source]);
   }
   void test_instanceMemberAccessFromStatic_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "  static foo() {", "    m();", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {}",
+        "  static foo() {",
+        "    m();",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
@@ skipping 24 matching lines @@
     assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidAnnotation_notVariableOrConstructorInvocation() {
     Source source = addSource(EngineTestCase.createSource(["typedef V();", "@V", "main() {", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidAnnotation_staticMethodReference() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static f() {}", "}", "@A.f", "main() {", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static f() {}",
+        "}",
+        "@A.f",
+        "main() {",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
   void test_invalidConstructorName_notEnclosingClassName() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  B() : super();", "}"]));
     resolve(source);
     assertErrors([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]);
     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]);
   }
   void test_invalidOverrideNamed_fewerNamedParameters() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m({a, b}) {}", "}", "class B extends A {", "  m({a}) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m({a, b}) {}",
+        "}",
+        "class B extends A {",
+        "  m({a}) {}",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.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}) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m({a, b}) {}",
+        "}",
+        "class B extends A {",
+        "  m({a, c}) {}",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_NAMED]);
     verify([source]);
   }
   void test_invalidOverridePositional() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m([a, b]) {}", "}", "class B extends A {", "  m([a]) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m([a, b]) {}",
+        "}",
+        "class B extends A {",
+        "  m([a]) {}",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_POSITIONAL]);
     verify([source]);
   }
   void test_invalidOverrideRequired() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m(a) {}", "}", "class B extends A {", "  m(a, b) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m(a) {}",
+        "}",
+        "class B extends A {",
+        "  m(a, b) {}",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_REQUIRED]);
     verify([source]);
   }
   void test_invalidReferenceToThis_factoryConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() { return this; }", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
     verify([source]);
   }
@@ skipping 27 matching lines @@
     assertErrors([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]);
     verify([source]);
   }
   void test_invalidTypeArgumentForKey() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {", "    return const <int, int>{};", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {",
+        "    return const <int, int>{};",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_FOR_KEY]);
     verify([source]);
   }
   void test_invalidTypeArgumentInConstList() {
-    Source source = addSource(EngineTestCase.createSource(["class A<E> {", "  m() {", "    return const <E>[];", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<E> {",
+        "  m() {",
+        "    return const <E>[];",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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>{};", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<E> {",
+        "  m() {",
+        "    return const <String, E>{};",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
   }
   void test_invalidUri_import() {
     Source source = addSource(EngineTestCase.createSource(["import 'ht:';"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.INVALID_URI]);
   }
   void test_invalidUri_part() {
     Source source = addSource(EngineTestCase.createSource(["part 'ht:';"]));
     resolve(source);
     assertErrors([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;", "      };", "    }", "  }", "}"]));
+    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]);
   }
   void test_labelUndefined_break() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  x: while (true) {", "    break y;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  x: while (true) {",
+        "    break y;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.LABEL_UNDEFINED]);
   }
   void test_labelUndefined_continue() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  x: while (true) {", "    continue y;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  x: while (true) {",
+        "    continue y;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
+    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]);
+    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]);
+    verify([source]);
+  }
   void test_memberWithClassName_field() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int A = 0;", "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_memberWithClassName_getter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  get A => 0;", "}"]));
     resolve(source);
     assertErrors([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([CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME, CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME]);
+    assertErrors([
+        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 {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "class B extends Object with A {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
   void test_mixinDeclaresConstructor_typedef() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "typedef B = Object with A;"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "typedef B = Object with A;"]));
     resolve(source);
     assertErrors([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 {}"]));
+    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]);
     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 {}"]));
+    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]);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_typedef_extends() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {}", "typedef C = Object with B;"]));
+    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]);
     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;"]));
+    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]);
     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]);
     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]);
     verify([source]);
   }
   void test_mixinReferencesSuper() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  toString() => super.toString();", "}", "class B extends Object with A {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  toString() => super.toString();",
+        "}",
+        "class B extends Object with A {}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     verify([source]);
   }
   void test_multipleRedirectingConstructorInvocations() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() : this.a(), this.b();", "  A.a() {}", "  A.b() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() : this.a(), this.b();",
+        "  A.a() {}",
+        "  A.b() {}",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS]);
     verify([source]);
   }
   void test_multipleSuperInitializers() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {", "  B() : super(), super() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  B() : super(), super() {}",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS]);
     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]);
     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]);
     verify([source]);
   }
   void test_newWithInvalidTypeParameters() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f() { return new A<A>(); }"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.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>();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class C<K, V> {}",
+        "f(p) {",
+        "  return new C<A>();",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.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>();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class C<E> {}",
+        "f(p) {",
+        "  return new C<A, A>();",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_noAnnotationConstructorArguments() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "@A", "main() {", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS]);
     verify([source]);
   }
   void test_noDefaultSuperConstructorExplicit() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A(p);", "}", "class B extends A {", "  B() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A(p);",
+        "}",
+        "class B extends A {",
+        "  B() {}",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     verify([source]);
   }
   void test_nonConstantAnnotationConstructor_named() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.fromInt() {}", "}", "@A.fromInt()", "main() {", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.fromInt() {}",
+        "}",
+        "@A.fromInt()",
+        "main() {",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
@@ skipping 27 matching lines @@
     assertErrors([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]);
     verify([source]);
   }
   void test_nonConstCaseExpression() {
-    Source source = addSource(EngineTestCase.createSource(["f(int p, int q) {", "  switch (p) {", "    case 3 + q:", "      break;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(int p, int q) {",
+        "  switch (p) {",
+        "    case 3 + q:",
+        "      break;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
@@ skipping 15 matching lines @@
     assertErrors([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]);
     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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final bool a;",
+        "  const A(String p) : a = p && true;",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
+    assertErrors([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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final bool a;",
+        "  const A(String p) : a = true && p;",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
+    assertErrors([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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final int a;",
+        "  const A(String p) : a = 5 & p;",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors([
+        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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final int a;",
+        "  const A(String p) : a = 5 + p;",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors([
+        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;", "}"]));
+    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]);
     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);", "}"]));
+    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]);
     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);", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonGenerativeConstructor_explicit() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A.named() {}", "}", "class B extends A {", "  B() : super.named();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  factory A.named() {}",
+        "}",
+        "class B extends A {",
+        "  B() : super.named();",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_nonGenerativeConstructor_implicit() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() {}", "}", "class B extends A {", "  B();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  factory A() {}",
+        "}",
+        "class B extends A {",
+        "  B();",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_nonGenerativeConstructor_implicit2() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  factory A() {}", "}", "class B extends A {", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  factory A() {}",
+        "}",
+        "class B extends A {",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
     verify([source]);
   }
   void test_notEnoughRequiredArguments_const() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A(int p);", "}", "main() {", "  const A();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(int p);",
+        "}",
+        "main() {",
+        "  const A();",
+        "}"]));
     resolve(source);
     assertErrors([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]);
+    verify([source]);
   }
   void test_optionalParameterInOperator_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator +({p}) {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR]);
     verify([source]);
   }
   void test_optionalParameterInOperator_positional() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator +([p]) {}", "}"]));
     resolve(source);
@@ skipping 47 matching lines @@
     assertErrors([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]);
     verify([source]);
   }
   void test_recursiveConstructorRedirect() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.a() : this.b();", "  A.b() : this.a();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.a() : this.b();",
+        "  A.b() : this.a();",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT, CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT]);
+    assertErrors([
+        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]);
     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;", "}"]));
+    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([CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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]);
     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;", "}"]));
+    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([CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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;", "}"]));
+    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([CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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;", "}"]));
+    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([CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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 {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A implements A {}",
+        "class B implements A {}"]));
     resolve(source);
     assertErrors([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 {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A implements B {}",
+        "abstract class B implements A {}",
+        "class C implements A {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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 {}"]));
+    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([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE, CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]);
+    assertErrors([
+        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]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritanceBaseCaseImplements() {
     Source source = addSource(EngineTestCase.createSource(["class A implements A {}"]));
     resolve(source);
     assertErrors([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;"]));
+    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]);
     verify([source]);
   }
   void test_redirectToNonConstConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.a() {}", "  const factory A.b() = A.a;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.a() {}",
+        "  const factory A.b() = A.a;",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
@@ skipping 20 matching lines @@
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
+  void test_returnInGenerativeConstructor_expressionFunctionBody() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() => null;", "}"]));
+    resolve(source);
+    assertErrors([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]);
   }
   void test_superInInvalidContext_constructorFieldInitializer() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "}", "class B extends A {", "  var f;", "  B() : f = super.m();", "}"]));
+    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]);
   }
   void test_superInInvalidContext_factoryConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "}", "class B extends A {", "  factory B() {", "    super.m();", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m() {}",
+        "}",
+        "class B extends A {",
+        "  factory B() {",
+        "    super.m();",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    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]);
   }
   void test_superInInvalidContext_staticMethod() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static m() {}", "}", "class B extends A {", "  static n() { return super.m(); }", "}"]));
+    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]);
   }
   void test_superInInvalidContext_staticVariableInitializer() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static int a = 0;", "}", "class B extends A {", "  static int b = super.a;", "}"]));
+    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]);
   }
   void test_superInInvalidContext_topLevelFunction() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  super.f();", "}"]));
     resolve(source);
     assertErrors([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]);
   }
   void test_superInRedirectingConstructor_redirectionSuper() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {", "  B() : this.name(), super();", "  B.name() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B {",
+        "  B() : this.name(), super();",
+        "  B.name() {}",
+        "}"]));
     resolve(source);
     assertErrors([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() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B {",
+        "  B() : super(), this.name();",
+        "  B.name() {}",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
@@ skipping 11 matching lines @@
   }
   void test_typeAliasCannotReferenceItself_returnType() {
     Source source = addSource(EngineTestCase.createSource(["typedef A A();"]));
     resolve(source);
     assertErrors([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([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    assertErrors([
+        CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
+        CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_typeVariableBounds() {
     Source source = addSource(EngineTestCase.createSource(["typedef A<T extends A>();"]));
     resolve(source);
     assertErrors([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>(); }"]));
+    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]);
     verify([source]);
   }
   void test_undefinedClass_const() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  return const A();", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.UNDEFINED_CLASS]);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_explicit_named() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {", "  B() : super.named();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  B() : super.named();",
+        "}"]));
     resolve(source);
     assertErrors([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();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.named() {}",
+        "}",
+        "class B extends A {",
+        "  B() : super();",
+        "}"]));
     resolve(source);
     assertErrors([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();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.named() {}",
+        "}",
+        "class B extends A {",
+        "  B();",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
     verify([source]);
   }
   void test_undefinedNamedParameter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "main() {", "  const A(p: 0);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "}",
+        "main() {",
+        "  const A(p: 0);",
+        "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER]);
   }
   void test_uriDoesNotExist_export() {
     Source source = addSource(EngineTestCase.createSource(["export 'unknown.dart';"]));
     resolve(source);
     assertErrors([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]);
   }
   void test_uriDoesNotExist_part() {
     Source source = addSource(EngineTestCase.createSource(["part 'unknown.dart';"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
   void test_uriWithInterpolation_constant() {
     Source source = addSource(EngineTestCase.createSource(["import 'stuff_\$platform.dart';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.URI_WITH_INTERPOLATION, StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors([
+        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]);
   }
   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]);
@@ skipping 69 matching lines @@
     assertErrors([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]);
       verify([source]);
     } else {
-      assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+      assertErrors([
+          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};", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final a;",
+        "  const A(bool p) : a = ${expr};",
+        "}"]));
     resolve(source);
     assertErrors([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};", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final a;",
+        "  const A(int p) : a = ${expr};",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_INT, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors([
+        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};", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final a;",
+        "  const A(num p) : a = ${expr};",
+        "}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_NUM, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors([
+        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]);
     verify([source]);
     reset();
   }
@@ skipping 44 matching lines @@
         runJUnitTest(__test, __test.test_ambiguousImport_varRead);
       });
       _ut.test('test_ambiguousImport_varWrite', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_varWrite);
       });
       _ut.test('test_argumentDefinitionTestNonParameter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter);
       });
+      _ut.test('test_argumentTypeNotAssignable_const', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_const);
+      });
+      _ut.test('test_argumentTypeNotAssignable_const_super', () {
+        final __test = new CompileTimeErrorCodeTest();
+        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', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 88 matching lines @@
         runJUnitTest(__test, __test.test_constEvalTypeBool_binary_leftTrue);
       });
       _ut.test('test_constEvalTypeInt_binary', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalTypeInt_binary);
       });
       _ut.test('test_constEvalTypeNum_binary', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalTypeNum_binary);
       });
+      _ut.test('test_constEvalTypeNum_plus_String', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constEvalTypeNum_plus_String);
+      });
       _ut.test('test_constEval_newInstance_constConstructor', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEval_newInstance_constConstructor);
       });
       _ut.test('test_constEval_propertyExtraction_methodInstance', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEval_propertyExtraction_methodInstance);
       });
       _ut.test('test_constEval_propertyExtraction_methodStatic_targetInstance', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 132 matching lines @@
         runJUnitTest(__test, __test.test_exportInternalLibrary);
       });
       _ut.test('test_exportOfNonLibrary', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_exportOfNonLibrary);
       });
       _ut.test('test_extendsNonClass_class', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extendsNonClass_class);
       });
+      _ut.test('test_extendsNonClass_dynamic', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extendsNonClass_dynamic);
+      });
       _ut.test('test_extendsOrImplementsDisallowedClass_extends_String', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_extends_String);
       });
       _ut.test('test_extendsOrImplementsDisallowedClass_extends_bool', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_extends_bool);
       });
       _ut.test('test_extendsOrImplementsDisallowedClass_extends_double', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 24 matching lines @@
         runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_int);
       });
       _ut.test('test_extendsOrImplementsDisallowedClass_implements_num', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_num);
       });
       _ut.test('test_extraPositionalArguments_const', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extraPositionalArguments_const);
       });
+      _ut.test('test_extraPositionalArguments_const_super', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_extraPositionalArguments_const_super);
+      });
       _ut.test('test_fieldInitializedByMultipleInitializers', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_fieldInitializedByMultipleInitializers);
       });
       _ut.test('test_fieldInitializedByMultipleInitializers_multipleInits', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_fieldInitializedByMultipleInitializers_multipleInits);
       });
       _ut.test('test_fieldInitializedByMultipleInitializers_multipleNames', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 72 matching lines @@
         runJUnitTest(__test, __test.test_implementsNonClass_typedef);
       });
       _ut.test('test_implementsRepeated', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsRepeated);
       });
       _ut.test('test_implementsRepeated_3times', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsRepeated_3times);
       });
+      _ut.test('test_implementsSuperClass', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_implementsSuperClass);
+      });
+      _ut.test('test_implementsSuperClass_Object', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_implementsSuperClass_Object);
+      });
       _ut.test('test_implicitThisReferenceInInitializer_field', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_field);
       });
       _ut.test('test_implicitThisReferenceInInitializer_field2', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_field2);
       });
       _ut.test('test_implicitThisReferenceInInitializer_invocation', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_invocation);
       });
+      _ut.test('test_implicitThisReferenceInInitializer_invocationInStatic', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_invocationInStatic);
+      });
       _ut.test('test_implicitThisReferenceInInitializer_redirectingConstructorInvocation', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_redirectingConstructorInvocation);
       });
       _ut.test('test_implicitThisReferenceInInitializer_superConstructorInvocation', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_superConstructorInvocation);
       });
       _ut.test('test_importInternalLibrary', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 164 matching lines @@
         runJUnitTest(__test, __test.test_labelInOuterScope);
       });
       _ut.test('test_labelUndefined_break', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_labelUndefined_break);
       });
       _ut.test('test_labelUndefined_continue', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_labelUndefined_continue);
       });
+      _ut.test('test_listElementTypeNotAssignable', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_listElementTypeNotAssignable);
+      });
+      _ut.test('test_mapKeyTypeNotAssignable', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_mapKeyTypeNotAssignable);
+      });
+      _ut.test('test_mapValueTypeNotAssignable', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_mapValueTypeNotAssignable);
+      });
       _ut.test('test_memberWithClassName_field', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_memberWithClassName_field);
       });
       _ut.test('test_memberWithClassName_field2', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_memberWithClassName_field2);
       });
       _ut.test('test_memberWithClassName_getter', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 188 matching lines @@
         runJUnitTest(__test, __test.test_nonGenerativeConstructor_implicit);
       });
       _ut.test('test_nonGenerativeConstructor_implicit2', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonGenerativeConstructor_implicit2);
       });
       _ut.test('test_notEnoughRequiredArguments_const', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_notEnoughRequiredArguments_const);
       });
+      _ut.test('test_notEnoughRequiredArguments_const_super', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_notEnoughRequiredArguments_const_super);
+      });
       _ut.test('test_optionalParameterInOperator_named', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_optionalParameterInOperator_named);
       });
       _ut.test('test_optionalParameterInOperator_positional', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_optionalParameterInOperator_positional);
       });
       _ut.test('test_partOfNonPart', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 112 matching lines @@
         runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_unqualifiedInvocation);
       });
       _ut.test('test_rethrowOutsideCatch', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_rethrowOutsideCatch);
       });
       _ut.test('test_returnInGenerativeConstructor', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_returnInGenerativeConstructor);
       });
+      _ut.test('test_returnInGenerativeConstructor_expressionFunctionBody', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_returnInGenerativeConstructor_expressionFunctionBody);
+      });
       _ut.test('test_superInInvalidContext_binaryExpression', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_superInInvalidContext_binaryExpression);
       });
       _ut.test('test_superInInvalidContext_constructorFieldInitializer', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_superInInvalidContext_constructorFieldInitializer);
       });
       _ut.test('test_superInInvalidContext_factoryConstructor', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 275 matching lines @@
     }
     return "<unknown file- ASTNode is null>";
   }
 }
 /**
  * The class `StrictModeTest` contains tests to ensure that the correct errors and warnings
  * are reported when the analysis engine is run in strict mode.
  */
 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];", "  }", "}"]));
+    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]);
   }
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strictMode = true;
     analysisContext.analysisOptions = options;
   }
   void test_assert_is() {
-    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  assert (n is int);", "  return n & 0x0F;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "int f(num n) {",
+        "  assert (n is int);",
+        "  return n & 0x0F;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "int f(num n) {",
+        "  return (n is int && n > 0) ? n & 0x0F : 0;",
+        "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_conditional_is() {
-    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  return (n is int) ? n & 0x0F : 0;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "int f(num n) {",
+        "  return (n is int) ? n & 0x0F : 0;",
+        "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_conditional_isNot() {
-    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  return (n is! int) ? 0 : n & 0x0F;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "int f(num n) {",
+        "  return (n is! int) ? 0 : n & 0x0F;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "int f(num n) {",
+        "  return (n is! int || n < 0) ? 0 : n & 0x0F;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "  }", "}"]));
+    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]);
   }
   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;", "}"]));
+    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]);
   }
   void test_if_is() {
-    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  if (n is int) {", "    return n & 0x0F;", "  }", "  return 0;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "int f(num n) {",
+        "  if (n is int) {",
+        "    return n & 0x0F;",
+        "  }",
+        "  return 0;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "  }", "}"]));
+    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]);
   }
   void test_if_isNot_abrupt() {
-    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  if (n is! int) {", "    return 0;", "  }", "  return n & 0x0F;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "int f(num n) {",
+        "  if (n is! int) {",
+        "    return 0;",
+        "  }",
+        "  return n & 0x0F;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "  }", "}"]));
+    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]);
   }
   void test_localVar() {
     Source source = addSource(EngineTestCase.createSource(["int f() {", "  num n = 1234;", "  return n & 0x0F;", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   static dartSuite() {
     _ut.group('StrictModeTest', () {
@@ skipping 87 matching lines @@
   void fail_visitImportDirective_combinators_noPrefix() {
     JUnitTestCase.fail("Not yet tested");
     ImportDirective directive = ASTFactory.importDirective2(null, null, [ASTFactory.showCombinator2(["A"])]);
     resolveNode(directive, []);
     _listener.assertNoErrors();
   }
   void fail_visitImportDirective_combinators_prefix() {
     JUnitTestCase.fail("Not yet tested");
     String prefixName = "p";
     _definingLibrary.imports = <ImportElement> [ElementFactory.importFor(null, ElementFactory.prefix(prefixName), [])];
-    ImportDirective directive = ASTFactory.importDirective2(null, prefixName, [ASTFactory.showCombinator2(["A"]), ASTFactory.hideCombinator2(["B"])]);
+    ImportDirective directive = ASTFactory.importDirective2(null, prefixName, [
+        ASTFactory.showCombinator2(["A"]),
+        ASTFactory.hideCombinator2(["B"])]);
     resolveNode(directive, []);
     _listener.assertNoErrors();
   }
   void fail_visitRedirectingConstructorInvocation() {
     JUnitTestCase.fail("Not yet tested");
     _listener.assertNoErrors();
   }
   void setUp() {
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
@@ skipping 733 matching lines @@
 }
 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]);
   }
   void test_import_packageWithDotDot() {
     Source source = addSource(EngineTestCase.createSource(["import 'package:somepackage/../other.dart';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST, PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT]);
+    assertErrors([
+        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([CompileTimeErrorCode.URI_DOES_NOT_EXIST, PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT]);
+    assertErrors([
+        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]);
   }
   void test_import_referenceIntoLibDirectory_no_pubspec() {
     cacheSource("/myproj/lib/other.dart", "");
@@ skipping 75 matching lines @@
       });
       _ut.test('test_import_valid_outside_lib', () {
         final __test = new PubSuggestionCodeTest();
         runJUnitTest(__test, __test.test_import_valid_outside_lib);
       });
     });
   }
 }
 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);", "  }", "}"]));
+    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]);
     verify([source]);
   }
   void fail_commentReferenceConstructorNotVisible() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticWarningCode.COMMENT_REFERENCE_CONSTRUCTOR_NOT_VISIBLE]);
     verify([source]);
   }
@@ skipping 14 matching lines @@
     resolve(source);
     assertErrors([StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_IDENTIFIER]);
     verify([source]);
   }
   void fail_commentReferenceUriNotLibrary() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticWarningCode.COMMENT_REFERENCE_URI_NOT_LIBRARY]);
     verify([source]);
   }
-  void fail_finalNotInitialized_inConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x;", "  A() {}", "}"]));
-    resolve(source);
-    assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
-    verify([source]);
-  }
   void fail_invalidFactoryName() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticWarningCode.INVALID_FACTORY_NAME]);
     verify([source]);
   }
   void fail_invocationOfNonFunction() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticWarningCode.INVOCATION_OF_NON_FUNCTION]);
     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) {}", "}"]));
+    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]);
     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 ''; }", "}"]));
+    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]);
     verify([source]);
   }
   void fail_undefinedGetter() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_GETTER]);
     verify([source]);
   }
   void fail_undefinedIdentifier_commentReference() {
     Source source = addSource(EngineTestCase.createSource(["/** [m] xxx [new B.c] */", "class A {", "}"]));
     resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER, StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    assertErrors([
+        StaticWarningCode.UNDEFINED_IDENTIFIER,
+        StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void fail_undefinedIdentifier_function() {
     Source source = addSource(EngineTestCase.createSource(["int a() => b;"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
     verify([source]);
   }
   void fail_undefinedSetter() {
     Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", "  C.m = 0;", "}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     verify([source]);
   }
   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> {}"]));
+    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([StaticWarningCode.AMBIGUOUS_IMPORT, StaticWarningCode.AMBIGUOUS_IMPORT, StaticWarningCode.AMBIGUOUS_IMPORT, StaticWarningCode.AMBIGUOUS_IMPORT, StaticWarningCode.AMBIGUOUS_IMPORT, StaticWarningCode.AMBIGUOUS_IMPORT, StaticWarningCode.AMBIGUOUS_IMPORT]);
+    assertErrors([
+        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() {}"]));
+    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]);
   }
   void test_argumentTypeNotAssignable_annotation_namedConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  const A.fromInt(int p);", "}", "@A.fromInt('0')", "main() {", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A.fromInt(int p);",
+        "}",
+        "@A.fromInt('0')",
+        "main() {",
+        "}"]));
     resolve(source);
     assertErrors([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() {", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A(int p);",
+        "}",
+        "@A('0')",
+        "main() {",
+        "}"]));
     resolve(source);
     assertErrors([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';", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  operator +(int p) {}",
+        "}",
+        "f(A a) {",
+        "  a + '0';",
+        "}"]));
     resolve(source);
     assertErrors([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'];", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  operator [](int index) {}",
+        "}",
+        "f(A a) {",
+        "  a['0'];",
+        "}"]));
     resolve(source);
     assertErrors([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');", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  call(int p) {}",
+        "}",
+        "f(A a) {",
+        "  a('0');",
+        "}"]));
     resolve(source);
     assertErrors([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');", "}"]));
+    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]);
     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]);
     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);", "}"]));
+    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]);
     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]);
     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]);
     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]);
     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]);
     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');", "}"]));
+    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]);
     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]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_new_generic() {
-    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  A(T p) {}", "}", "main() {", "  new A<String>(42);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<T> {",
+        "  A(T p) {}",
+        "}",
+        "main() {",
+        "  new A<String>(42);",
+        "}"]));
     resolve(source);
     assertErrors([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);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A([String p]) {}",
+        "}",
+        "main() {",
+        "  new A(42);",
+        "}"]));
     resolve(source);
     assertErrors([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);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A(String p) {}",
+        "}",
+        "main() {",
+        "  new A(42);",
+        "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_assignmentToFinal_instanceVariable() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  final v = 0;", "}", "f() {", "  A a = new A();", "  a.v = 1;", "}"]));
+    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]);
     verify([source]);
   }
   void test_assignmentToFinal_localVariable() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  x = 1;", "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_assignmentToFinal_prefixPlusPlus() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  ++x;", "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    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]);
     verify([source]);
   }
   void test_assignmentToFinal_suffixMinusMinus() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  final x = 0;", "  x--;", "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_assignmentToFinal_topLevelVariable() {
     Source source = addSource(EngineTestCase.createSource(["final x = 0;", "f() { x = 1; }"]));
     resolve(source);
     assertErrors([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]);
+    verify([source]);
+  }
   void test_caseBlockNotTerminated() {
-    Source source = addSource(EngineTestCase.createSource(["f(int p) {", "  switch (p) {", "    case 0:", "      f(p);", "    case 1:", "      break;", "  }", "}"]));
+    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]);
     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]);
     verify([source]);
   }
   void test_concreteClassWithAbstractMember() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m();", "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    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]);
     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;", "}"]));
+    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]);
     verify([source]);
   }
   void test_conflictingInstanceGetterAndSuperclassMember_direct_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static v() {}", "}", "class B extends A {", "  get v => 0;", "}"]));
+    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]);
     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;", "}"]));
+    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]);
     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;", "}"]));
+    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]);
     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;", "}"]));
+    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]);
     verify([source]);
   }
   void test_conflictingInstanceSetterAndSuperclassMember() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static int v;", "}", "class B extends A {", "  set v(x) {}", "}"]));
+    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]);
     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;", "}"]));
+    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]);
     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;", "}"]));
+    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]);
     verify([source]);
   }
   void test_conflictingStaticGetterAndInstanceSetter_thisClass() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static get x => 0;", "  set x(int p) {}", "}"]));
+    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]);
     verify([source]);
   }
   void test_conflictingStaticSetterAndInstanceMember_thisClass_getter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  get x => 0;", "  static set x(int p) {}", "}"]));
+    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]);
     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]);
     verify([source]);
   }
   void test_constWithAbstractClass() {
-    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  const A();", "}", "void f() {", "  A a = const A();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A {",
+        "  const A();",
+        "}",
+        "void f() {",
+        "  A a = const A();",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
   void test_exportDuplicatedLibraryName() {
-    Source source = addSource(EngineTestCase.createSource(["library test;", "export 'lib1.dart';", "export 'lib2.dart';"]));
+    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]);
     verify([source]);
   }
   void test_extraPositionalArguments() {
     Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", "  f(0, 1, '2');", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS]);
     verify([source]);
   }
   void test_fieldInitializerNotAssignable() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A() : x = '';", "}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     verify([source]);
   }
   void test_finalNotInitialized_instanceField_final() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final F;", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.FINAL_NOT_INITIALIZED]);
@@ skipping 23 matching lines @@
     assertErrors([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]);
     verify([source]);
   }
   void test_importDuplicatedLibraryName() {
-    Source source = addSource(EngineTestCase.createSource(["library test;", "import 'lib1.dart';", "import 'lib2.dart';"]));
+    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([StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAME]);
     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 {", "}"]));
+    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]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_field() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static var n;", "}", "class B extends A {", "  void n() {}", "}"]));
+    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]);
     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() {}", "}"]));
+    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]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_getter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static get n {return 0;}", "}", "class B extends A {", "  void n() {}", "}"]));
+    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]);
     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() {}", "}"]));
+    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]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static n () {}", "}", "class B extends A {", "  void n() {}", "}"]));
+    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]);
     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() {}", "}"]));
+    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]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_setter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static set n(int x) {}", "}", "class B extends A {", "  void n() {}", "}"]));
+    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]);
     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() {}", "}"]));
+    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]);
     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'; }", "}"]));
+    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]);
     verify([source]);
   }
+  void test_invalidGetterOverrideReturnType_implicit() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  String f;",
+        "}",
+        "class B extends A {",
+        "  int f;",
+        "}"]));
+    resolve(source);
+    assertErrors([
+        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}) {}", "}"]));
+    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]);
     verify([source]);
   }
   void test_invalidMethodOverrideNormalParamType() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m(int a) {}", "}", "class B implements A {", "  m(String a) {}", "}"]));
+    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]);
     verify([source]);
   }
   void test_invalidMethodOverrideOptionalParamType() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m([int a]) {}", "}", "class B implements A {", "  m([String a]) {}", "}"]));
+    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]);
     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'; }", "}"]));
+    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]);
     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'; }", "}"]));
+    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]);
     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'; }", "}"]));
+    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]);
     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'; }", "}"]));
+    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]);
     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'; }", "}"]));
+    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]);
     verify([source]);
   }
   void test_invalidMethodOverrideReturnType_void() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int m() {}", "}", "class B extends A {", "  void m() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int m() {}",
+        "}",
+        "class B extends A {",
+        "  void m() {}",
+        "}"]));
     resolve(source);
     assertErrors([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}) {}", "}"]));
+    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]);
     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]) {}", "}"]));
+    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]);
     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) {}", "}"]));
+    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]);
     verify([source]);
   }
+  void test_listElementTypeNotAssignable() {
+    Source source = addSource(EngineTestCase.createSource(["var v = <String> [42];"]));
+    resolve(source);
+    assertErrors([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]);
+    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]);
+    verify([source]);
+  }
   void test_mismatchedAccessorTypes_class() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int get g { return 0; }", "  set g(String v) {}", "}"]));
+    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]);
     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]);
     verify([source]);
   }
   void test_newWithAbstractClass() {
-    Source source = addSource(EngineTestCase.createSource(["abstract class A {}", "void f() {", "  A a = new A();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A {}",
+        "void f() {",
+        "  A a = new A();",
+        "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NEW_WITH_ABSTRACT_CLASS]);
     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]);
     verify([source]);
   }
   void test_newWithNonType_fromLibrary() {
     Source source1 = addSource2("lib.dart", "");
-    Source source2 = addSource2("lib2.dart", EngineTestCase.createSource(["import 'lib.dart' as lib;", "void f() {", "  var a = new lib.A();", "}"]));
+    Source source2 = addSource2("lib2.dart", EngineTestCase.createSource([
+        "import 'lib.dart' as lib;",
+        "void f() {",
+        "  var a = new lib.A();",
+        "}"]));
     resolve(source1);
     resolve(source2);
     assertErrors([StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source1]);
   }
   void test_newWithUndefinedConstructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "f() {", "  new A.name();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "f() {",
+        "  new A.name();",
+        "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR]);
   }
   void test_newWithUndefinedConstructorDefault() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A.name() {}", "}", "f() {", "  new A();", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A.name() {}",
+        "}",
+        "f() {",
+        "  new A();",
+        "}"]));
     resolve(source);
     assertErrors([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 {", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberFour() {
-    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "  o();", "  p();", "}", "class C extends A {", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface() {
-    Source source = addSource(EngineTestCase.createSource(["class I {", "  int get g {return 1;}", "}", "class C implements I {", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromSuperclass() {
-    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  int get g;", "}", "class C extends A {", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface() {
-    Source source = addSource(EngineTestCase.createSource(["class I {", "  m(p) {}", "}", "class C implements I {", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class I {",
+        "  m(p) {}",
+        "}",
+        "class C implements I {",
+        "}"]));
     resolve(source);
     assertErrors([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 {", "}"]));
+    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]);
     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 {", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface() {
-    Source source = addSource(EngineTestCase.createSource(["class I {", "  set s(int i) {}", "}", "class C implements I {", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass() {
-    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  set s(int i);", "}", "class C extends A {", "}"]));
+    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]);
     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 {", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberThree() {
-    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "  o();", "}", "class C extends A {", "}"]));
+    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]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberTwo() {
-    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "}", "class C extends A {", "}"]));
+    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]);
     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]);
     verify([source]);
   }
   void test_nonTypeInCatchClause_notType() {
-    Source source = addSource(EngineTestCase.createSource(["var T = 0;", "f() {", "  try {", "  } on T catch (e) {", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "var T = 0;",
+        "f() {",
+        "  try {",
+        "  } on T catch (e) {",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     verify([source]);
   }
   void test_nonVoidReturnForSetter_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int set x(int v) {", "    return 42;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int set x(int v) {",
+        "    return 42;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     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]);
     verify([source]);
   }
   void test_redirectToInvalidFunctionType() {
-    Source source = addSource(EngineTestCase.createSource(["class A implements B {", "  A(int p) {}", "}", "class B {", "  B() = A;", "}"]));
+    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]);
     verify([source]);
   }
   void test_redirectToInvalidReturnType() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B {", "  B() = A;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "class B {",
+        "  factory B() = A;",
+        "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE]);
     verify([source]);
   }
   void test_redirectToMissingConstructor_named() {
-    Source source = addSource(EngineTestCase.createSource(["class A implements B{", "  A() {}", "}", "class B {", "  B() = A.name;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A implements B{",
+        "  A() {}",
+        "}",
+        "class B {",
+        "  factory B() = A.name;",
+        "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
   }
   void test_redirectToMissingConstructor_unnamed() {
-    Source source = addSource(EngineTestCase.createSource(["class A implements B{", "  A.name() {}", "}", "class B {", "  B() = A;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A implements B{",
+        "  A.name() {}",
+        "}",
+        "class B {",
+        "  factory B() = A;",
+        "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
   }
   void test_redirectToNonClass_notAType() {
-    Source source = addSource(EngineTestCase.createSource(["class B {", "  int A;", "  B() = A;", "}"]));
+    Source source = addSource(EngineTestCase.createSource(["class B {", "  int A;", "  factory B() = A;", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.REDIRECT_TO_NON_CLASS]);
     verify([source]);
   }
   void test_redirectToNonClass_undefinedIdentifier() {
-    Source source = addSource(EngineTestCase.createSource(["class B {", "  B() = A;", "}"]));
+    Source source = addSource(EngineTestCase.createSource(["class B {", "  factory B() = A;", "}"]));
     resolve(source);
     assertErrors([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]);
     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]);
     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]);
     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]);
     verify([source]);
   }
   void test_staticAccessToInstanceMember_propertyAccess_getter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  get f => 42;", "}", "main() {", "  A.f;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  get f => 42;",
+        "}",
+        "main() {",
+        "  A.f;",
+        "}"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  set f(x) {}",
+        "}",
+        "main() {",
+        "  A.f = 42;",
+        "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER]);
     verify([source]);
   }
   void test_switchExpressionNotAssignable() {
-    Source source = addSource(EngineTestCase.createSource(["f(int p) {", "  switch (p) {", "    case 'a': break;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f(int p) {",
+        "  switch (p) {",
+        "    case 'a': break;",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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]);
     verify([source]);
   }
@@ skipping 43 matching lines @@
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_CLASS]);
   }
   void test_undefinedClassBoolean_variableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["f() { boolean v; }"]));
     resolve(source);
     assertErrors([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;", "}"]));
+    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]);
     verify([source1]);
   }
   void test_undefinedIdentifier_initializer() {
     Source source = addSource(EngineTestCase.createSource(["var a = b;"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
@@ skipping 115 matching lines @@
         runJUnitTest(__test, __test.test_assignmentToFinal_suffixMinusMinus);
       });
       _ut.test('test_assignmentToFinal_suffixPlusPlus', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_assignmentToFinal_suffixPlusPlus);
       });
       _ut.test('test_assignmentToFinal_topLevelVariable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_assignmentToFinal_topLevelVariable);
       });
+      _ut.test('test_assignmentToMethod', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_assignmentToMethod);
+      });
       _ut.test('test_caseBlockNotTerminated', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_caseBlockNotTerminated);
       });
       _ut.test('test_castToNonType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_castToNonType);
       });
       _ut.test('test_concreteClassWithAbstractMember', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 64 matching lines @@
         runJUnitTest(__test, __test.test_extraPositionalArguments);
       });
       _ut.test('test_fieldInitializerNotAssignable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_fieldInitializerNotAssignable);
       });
       _ut.test('test_fieldInitializingFormalNotAssignable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_fieldInitializingFormalNotAssignable);
       });
+      _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();
@@ skipping 52 matching lines @@
         runJUnitTest(__test, __test.test_instanceMethodNameCollidesWithSuperclassStatic_setter);
       });
       _ut.test('test_instanceMethodNameCollidesWithSuperclassStatic_setter2', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_instanceMethodNameCollidesWithSuperclassStatic_setter2);
       });
       _ut.test('test_invalidGetterOverrideReturnType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidGetterOverrideReturnType);
       });
+      _ut.test('test_invalidGetterOverrideReturnType_implicit', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_invalidGetterOverrideReturnType_implicit);
+      });
       _ut.test('test_invalidMethodOverrideNamedParamType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidMethodOverrideNamedParamType);
       });
       _ut.test('test_invalidMethodOverrideNormalParamType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidMethodOverrideNormalParamType);
       });
       _ut.test('test_invalidMethodOverrideOptionalParamType', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 28 matching lines @@
         runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_named);
       });
       _ut.test('test_invalidOverrideDifferentDefaultValues_positional', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_positional);
       });
       _ut.test('test_invalidSetterOverrideNormalParamType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidSetterOverrideNormalParamType);
       });
+      _ut.test('test_listElementTypeNotAssignable', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_listElementTypeNotAssignable);
+      });
+      _ut.test('test_mapKeyTypeNotAssignable', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_mapKeyTypeNotAssignable);
+      });
+      _ut.test('test_mapValueTypeNotAssignable', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_mapValueTypeNotAssignable);
+      });
       _ut.test('test_mismatchedAccessorTypes_class', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_mismatchedAccessorTypes_class);
       });
       _ut.test('test_mismatchedAccessorTypes_topLevel', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_mismatchedAccessorTypes_topLevel);
       });
       _ut.test('test_newWithAbstractClass', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 205 matching lines @@
       });
       _ut.test('test_undefinedNamedParameter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedNamedParameter);
       });
     });
   }
 }
 class ErrorResolverTest extends ResolverTestCase {
   void test_breakLabelOnSwitchMember() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void m(int i) {", "    switch (i) {", "      l: case 0:", "        break;", "      case 1:", "        break l;", "    }", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void m(int i) {",
+        "    switch (i) {",
+        "      l: case 0:",
+        "        break;",
+        "      case 1:",
+        "        break l;",
+        "    }",
+        "  }",
+        "}"]));
     resolve(source);
     assertErrors([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;", "    }", "  }", "}"]));
+    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]);
     verify([source]);
   }
   static dartSuite() {
     _ut.group('ErrorResolverTest', () {
       _ut.test('test_breakLabelOnSwitchMember', () {
         final __test = new ErrorResolverTest();
         runJUnitTest(__test, __test.test_breakLabelOnSwitchMember);
       });
@@ skipping 123 matching lines @@
     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;
-      iterableElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("iterator", false, iteratorType.substitute4(<Type2> [eType])), ElementFactory.getterElement("last", false, eType)];
+      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;
       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;
       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])];
+      listElement.methods = <MethodElement> [
+          ElementFactory.methodElement("[]", eType, [intType]),
+          ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [intType, eType]),
+          ElementFactory.methodElement("add", VoidTypeImpl.instance, [eType])];
       propagateTypeArguments(listElement);
     }
     return _listType;
   }
   InterfaceType get mapType {
     if (_mapType == null) {
       ClassElementImpl mapElement = ElementFactory.classElement2("Map", ["K", "V"]);
       _mapType = mapElement.type;
       mapElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("length", false, intType)];
       propagateTypeArguments(mapElement);
     }
     return _mapType;
   }
   InterfaceType get numType {
     if (_numType == null) {
       initializeNumericTypes();
     }
     return _numType;
   }
   InterfaceType get objectType {
     if (_objectType == null) {
       ClassElementImpl objectElement = ElementFactory.object;
       _objectType = objectElement.type;
       if (objectElement.methods.length == 0) {
         objectElement.constructors = <ConstructorElement> [ElementFactory.constructorElement(objectElement, null)];
-        objectElement.methods = <MethodElement> [ElementFactory.methodElement("toString", stringType, []), ElementFactory.methodElement("==", boolType, [_objectType]), ElementFactory.methodElement("noSuchMethod", dynamicType, [dynamicType])];
-        objectElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("hashCode", false, intType), ElementFactory.getterElement("runtimeType", false, typeType)];
+        objectElement.methods = <MethodElement> [
+            ElementFactory.methodElement("toString", stringType, []),
+            ElementFactory.methodElement("==", boolType, [_objectType]),
+            ElementFactory.methodElement("noSuchMethod", dynamicType, [dynamicType])];
+        objectElement.accessors = <PropertyAccessorElement> [
+            ElementFactory.getterElement("hashCode", false, intType),
+            ElementFactory.getterElement("runtimeType", false, typeType)];
       }
     }
     return _objectType;
   }
   InterfaceType get stackTraceType {
     if (_stackTraceType == null) {
       _stackTraceType = ElementFactory.classElement2("StackTrace", []).type;
     }
     return _stackTraceType;
   }
   InterfaceType get stringType {
     if (_stringType == null) {
       _stringType = ElementFactory.classElement2("String", []).type;
       ClassElementImpl stringElement = _stringType.element as ClassElementImpl;
-      stringElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("isEmpty", false, boolType), ElementFactory.getterElement("length", false, intType), ElementFactory.getterElement("codeUnits", false, listType.substitute4(<Type2> [intType]))];
-      stringElement.methods = <MethodElement> [ElementFactory.methodElement("toLowerCase", _stringType, []), ElementFactory.methodElement("toUpperCase", _stringType, [])];
+      stringElement.accessors = <PropertyAccessorElement> [
+          ElementFactory.getterElement("isEmpty", false, boolType),
+          ElementFactory.getterElement("length", false, intType),
+          ElementFactory.getterElement("codeUnits", false, listType.substitute4(<Type2> [intType]))];
+      stringElement.methods = <MethodElement> [
+          ElementFactory.methodElement("+", _stringType, [_stringType]),
+          ElementFactory.methodElement("toLowerCase", _stringType, []),
+          ElementFactory.methodElement("toUpperCase", _stringType, [])];
     }
     return _stringType;
   }
   InterfaceType get symbolType {
     if (_symbolType == null) {
       _symbolType = ElementFactory.classElement2("Symbol", []).type;
     }
     return _symbolType;
   }
   InterfaceType get typeType {
     if (_typeType == null) {
       _typeType = ElementFactory.classElement2("Type", []).type;
     }
     return _typeType;
   }
 
   /**
    * Initialize the numeric types. They are created as a group so that we can (a) create the right
    * hierarchy and (b) add members to them.
    */
   void initializeNumericTypes() {
     ClassElementImpl numElement = ElementFactory.classElement2("num", []);
     _numType = numElement.type;
     ClassElementImpl intElement = ElementFactory.classElement("int", _numType, []);
     _intType = intElement.type;
     ClassElementImpl doubleElement = ElementFactory.classElement("double", _numType, []);
     _doubleType = doubleElement.type;
     boolType;
     stringType;
-    numElement.methods = <MethodElement> [ElementFactory.methodElement("+", _numType, [_numType]), ElementFactory.methodElement("-", _numType, [_numType]), ElementFactory.methodElement("*", _numType, [_numType]), ElementFactory.methodElement("%", _numType, [_numType]), ElementFactory.methodElement("/", _doubleType, [_numType]), ElementFactory.methodElement("~/", _numType, [_numType]), ElementFactory.methodElement("-", _numType, []), ElementFactory.methodElement("remainder", _numType, [_numType]), ElementFactory.methodElement("<", _boolType, [_numType]), ElementFactory.methodElement("<=", _boolType, [_numType]), ElementFactory.methodElement(">", _boolType, [_numType]), ElementFactory.methodElement(">=", _boolType, [_numType]), ElementFactory.methodElement("isNaN", _boolType, []), ElementFactory.methodElement("isNegative", _boolType, []), ElementFactory.methodElement("isInfinite", _boolType, []), ElementFactory.methodElement("abs", _numType, []), ElementFactory.methodElement("floor", _numType, []), ElementFactory.methodElement("ceil", _numType, []), ElementFactory.methodElement("round", _numType, []), ElementFactory.methodElement("truncate", _numType, []), ElementFactory.methodElement("toInt", _intType, []), ElementFactory.methodElement("toDouble", _doubleType, []), ElementFactory.methodElement("toStringAsFixed", _stringType, [_intType]), ElementFactory.methodElement("toStringAsExponential", _stringType, [_intType]), ElementFactory.methodElement("toStringAsPrecision", _stringType, [_intType]), ElementFactory.methodElement("toRadixString", _stringType, [_intType])];
-    intElement.methods = <MethodElement> [ElementFactory.methodElement("&", _intType, [_intType]), ElementFactory.methodElement("|", _intType, [_intType]), ElementFactory.methodElement("^", _intType, [_intType]), ElementFactory.methodElement("~", _intType, []), ElementFactory.methodElement("<<", _intType, [_intType]), ElementFactory.methodElement(">>", _intType, [_intType]), ElementFactory.methodElement("-", _intType, []), ElementFactory.methodElement("abs", _intType, []), ElementFactory.methodElement("round", _intType, []), ElementFactory.methodElement("floor", _intType, []), ElementFactory.methodElement("ceil", _intType, []), ElementFactory.methodElement("truncate", _intType, []), ElementFactory.methodElement("toString", _stringType, [])];
-    List<FieldElement> fields = <FieldElement> [ElementFactory.fieldElement("NAN", true, false, true, _doubleType), ElementFactory.fieldElement("INFINITY", true, false, true, _doubleType), ElementFactory.fieldElement("NEGATIVE_INFINITY", true, false, true, _doubleType), ElementFactory.fieldElement("MIN_POSITIVE", true, false, true, _doubleType), ElementFactory.fieldElement("MAX_FINITE", true, false, true, _doubleType)];
+    numElement.methods = <MethodElement> [
+        ElementFactory.methodElement("+", _numType, [_numType]),
+        ElementFactory.methodElement("-", _numType, [_numType]),
+        ElementFactory.methodElement("*", _numType, [_numType]),
+        ElementFactory.methodElement("%", _numType, [_numType]),
+        ElementFactory.methodElement("/", _doubleType, [_numType]),
+        ElementFactory.methodElement("~/", _numType, [_numType]),
+        ElementFactory.methodElement("-", _numType, []),
+        ElementFactory.methodElement("remainder", _numType, [_numType]),
+        ElementFactory.methodElement("<", _boolType, [_numType]),
+        ElementFactory.methodElement("<=", _boolType, [_numType]),
+        ElementFactory.methodElement(">", _boolType, [_numType]),
+        ElementFactory.methodElement(">=", _boolType, [_numType]),
+        ElementFactory.methodElement("isNaN", _boolType, []),
+        ElementFactory.methodElement("isNegative", _boolType, []),
+        ElementFactory.methodElement("isInfinite", _boolType, []),
+        ElementFactory.methodElement("abs", _numType, []),
+        ElementFactory.methodElement("floor", _numType, []),
+        ElementFactory.methodElement("ceil", _numType, []),
+        ElementFactory.methodElement("round", _numType, []),
+        ElementFactory.methodElement("truncate", _numType, []),
+        ElementFactory.methodElement("toInt", _intType, []),
+        ElementFactory.methodElement("toDouble", _doubleType, []),
+        ElementFactory.methodElement("toStringAsFixed", _stringType, [_intType]),
+        ElementFactory.methodElement("toStringAsExponential", _stringType, [_intType]),
+        ElementFactory.methodElement("toStringAsPrecision", _stringType, [_intType]),
+        ElementFactory.methodElement("toRadixString", _stringType, [_intType])];
+    intElement.methods = <MethodElement> [
+        ElementFactory.methodElement("&", _intType, [_intType]),
+        ElementFactory.methodElement("|", _intType, [_intType]),
+        ElementFactory.methodElement("^", _intType, [_intType]),
+        ElementFactory.methodElement("~", _intType, []),
+        ElementFactory.methodElement("<<", _intType, [_intType]),
+        ElementFactory.methodElement(">>", _intType, [_intType]),
+        ElementFactory.methodElement("-", _intType, []),
+        ElementFactory.methodElement("abs", _intType, []),
+        ElementFactory.methodElement("round", _intType, []),
+        ElementFactory.methodElement("floor", _intType, []),
+        ElementFactory.methodElement("ceil", _intType, []),
+        ElementFactory.methodElement("truncate", _intType, []),
+        ElementFactory.methodElement("toString", _stringType, [])];
+    List<FieldElement> fields = <FieldElement> [
+        ElementFactory.fieldElement("NAN", true, false, true, _doubleType),
+        ElementFactory.fieldElement("INFINITY", true, false, true, _doubleType),
+        ElementFactory.fieldElement("NEGATIVE_INFINITY", true, false, true, _doubleType),
+        ElementFactory.fieldElement("MIN_POSITIVE", true, false, true, _doubleType),
+        ElementFactory.fieldElement("MAX_FINITE", true, false, true, _doubleType)];
     doubleElement.fields = fields;
     int fieldCount = fields.length;
     List<PropertyAccessorElement> accessors = new List<PropertyAccessorElement>(fieldCount);
     for (int i = 0; i < fieldCount; i++) {
       accessors[i] = fields[i].getter;
     }
     doubleElement.accessors = accessors;
-    doubleElement.methods = <MethodElement> [ElementFactory.methodElement("remainder", _doubleType, [_numType]), ElementFactory.methodElement("+", _doubleType, [_numType]), ElementFactory.methodElement("-", _doubleType, [_numType]), ElementFactory.methodElement("*", _doubleType, [_numType]), ElementFactory.methodElement("%", _doubleType, [_numType]), ElementFactory.methodElement("/", _doubleType, [_numType]), ElementFactory.methodElement("~/", _doubleType, [_numType]), ElementFactory.methodElement("-", _doubleType, []), ElementFactory.methodElement("abs", _doubleType, []), ElementFactory.methodElement("round", _doubleType, []), ElementFactory.methodElement("floor", _doubleType, []), ElementFactory.methodElement("ceil", _doubleType, []), ElementFactory.methodElement("truncate", _doubleType, []), ElementFactory.methodElement("toString", _stringType, [])];
+    doubleElement.methods = <MethodElement> [
+        ElementFactory.methodElement("remainder", _doubleType, [_numType]),
+        ElementFactory.methodElement("+", _doubleType, [_numType]),
+        ElementFactory.methodElement("-", _doubleType, [_numType]),
+        ElementFactory.methodElement("*", _doubleType, [_numType]),
+        ElementFactory.methodElement("%", _doubleType, [_numType]),
+        ElementFactory.methodElement("/", _doubleType, [_numType]),
+        ElementFactory.methodElement("~/", _doubleType, [_numType]),
+        ElementFactory.methodElement("-", _doubleType, []),
+        ElementFactory.methodElement("abs", _doubleType, []),
+        ElementFactory.methodElement("round", _doubleType, []),
+        ElementFactory.methodElement("floor", _doubleType, []),
+        ElementFactory.methodElement("ceil", _doubleType, []),
+        ElementFactory.methodElement("truncate", _doubleType, []),
+        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);
@@ skipping 23 matching lines @@
    * @return the analysis context that was created
    */
   static AnalysisContextImpl contextWithCore() {
     AnalysisContextImpl sdkContext = DirectoryBasedDartSdk.defaultSdk.context as AnalysisContextImpl;
     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.numType.element, provider.objectType.element, provider.stackTraceType.element, provider.stringType.element, provider.typeType.element];
+    coreUnit.types = <ClassElement> [
+        provider.boolType.element,
+        provider.doubleType.element,
+        provider.functionType.element,
+        provider.intType.element,
+        provider.listType.element,
+        provider.mapType.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.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);
     AnalysisContextImpl context = new DelegatingAnalysisContextImpl();
-    sourceFactory = new SourceFactory.con2([new DartUriResolver(sdkContext.sourceFactory.dartSdk), new FileUriResolver()]);
+    sourceFactory = new SourceFactory.con2([
+        new DartUriResolver(sdkContext.sourceFactory.dartSdk),
+        new FileUriResolver()]);
     context.sourceFactory = sourceFactory;
     return context;
   }
 }
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
     AnalysisContext context = new AnalysisContextImpl();
     String typeNameA = "A";
     String typeNameB = "B";
     String typeNameC = "C";
@@ skipping 743 matching lines @@
     Type2 resultType = analyze(node);
     assertType2(_typeProvider.mapType.substitute4(<Type2> [_typeProvider.dynamicType, _typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
   void test_visitMapLiteral_nonEmpty() {
     Expression node = ASTFactory.mapLiteral2([ASTFactory.mapLiteralEntry("k", resolvedInteger(0))]);
     Type2 resultType = analyze(node);
     assertType2(_typeProvider.mapType.substitute4(<Type2> [_typeProvider.dynamicType, _typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
+  void test_visitMethodInvocation_then() {
+    Expression node = ASTFactory.methodInvocation(null, "then", []);
+    analyze(node);
+    _listener.assertNoErrors();
+  }
   void test_visitNamedExpression() {
     Expression node = ASTFactory.namedExpression2("n", resolvedString("a"));
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitNullLiteral() {
     Expression node = ASTFactory.nullLiteral();
     JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node));
     _listener.assertNoErrors();
   }
@@ skipping 95 matching lines @@
     node.propertyName.element = setter;
     JUnitTestCase.assertSame(boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitSimpleStringLiteral() {
     Expression node = resolvedString("a");
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitStringInterpolation() {
-    Expression node = ASTFactory.string([ASTFactory.interpolationString("a", "a"), ASTFactory.interpolationExpression(resolvedString("b")), ASTFactory.interpolationString("c", "c")]);
+    Expression node = ASTFactory.string([
+        ASTFactory.interpolationString("a", "a"),
+        ASTFactory.interpolationExpression(resolvedString("b")),
+        ASTFactory.interpolationString("c", "c")]);
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitSuperExpression() {
     InterfaceType superType = ElementFactory.classElement2("A", []).type;
     InterfaceType thisType = ElementFactory.classElement("B", superType, []).type;
     Expression node = ASTFactory.superExpression();
     JUnitTestCase.assertSame(thisType, analyze2(node, thisType));
     _listener.assertNoErrors();
   }
@@ skipping 412 matching lines @@
         runJUnitTest(__test, __test.test_visitListLiteral_nonEmpty);
       });
       _ut.test('test_visitMapLiteral_empty', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitMapLiteral_empty);
       });
       _ut.test('test_visitMapLiteral_nonEmpty', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitMapLiteral_nonEmpty);
       });
+      _ut.test('test_visitMethodInvocation_then', () {
+        final __test = new StaticTypeAnalyzerTest();
+        runJUnitTest(__test, __test.test_visitMethodInvocation_then);
+      });
       _ut.test('test_visitNamedExpression', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitNamedExpression);
       });
       _ut.test('test_visitNullLiteral', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitNullLiteral);
       });
       _ut.test('test_visitParenthesizedExpression', () {
         final __test = new StaticTypeAnalyzerTest();
@@ skipping 73 matching lines @@
       });
       _ut.test('test_visitThrowExpression_withoutValue', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitThrowExpression_withoutValue);
       });
     });
   }
 }
 class NonHintCodeTest extends ResolverTestCase {
   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) {}", "}"]));
+    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();
     verify([source]);
   }
   static dartSuite() {
     _ut.group('NonHintCodeTest', () {
       _ut.test('test_deadCode_deadCatch_onCatchSubtype', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadCatch_onCatchSubtype);
       });
@@ skipping 56 matching lines @@
 class LibraryElementBuilderTest extends EngineTestCase {
 
   /**
    * The source factory used to create [Source].
    */
   SourceFactory _sourceFactory;
   void setUp() {
     _sourceFactory = new SourceFactory.con2([new FileUriResolver()]);
   }
   void test_accessorsAcrossFiles() {
-    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "part 'first.dart';", "part 'second.dart';"]));
+    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource([
+        "library lib;",
+        "part 'first.dart';",
+        "part 'second.dart';"]));
     addSource("/first.dart", EngineTestCase.createSource(["part of lib;", "int get V => 0;"]));
     addSource("/second.dart", EngineTestCase.createSource(["part of lib;", "void set V(int v) {}"]));
     LibraryElement element = buildLibrary(librarySource, []);
     JUnitTestCase.assertNotNull(element);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     EngineTestCase.assertLength(2, sourcedUnits);
     List<PropertyAccessorElement> firstAccessors = sourcedUnits[0].accessors;
     EngineTestCase.assertLength(1, firstAccessors);
     List<PropertyAccessorElement> secondAccessors = sourcedUnits[1].accessors;
     EngineTestCase.assertLength(1, secondAccessors);
@@ skipping 31 matching lines @@
     LibraryElement element = buildLibrary(librarySource, [ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART]);
     JUnitTestCase.assertNotNull(element);
   }
   void test_missingPartOfDirective() {
     addSource("/a.dart", "class A {}");
     Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';"]));
     LibraryElement element = buildLibrary(librarySource, [CompileTimeErrorCode.PART_OF_NON_PART]);
     JUnitTestCase.assertNotNull(element);
   }
   void test_multipleFiles() {
-    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "part 'first.dart';", "part 'second.dart';", "", "class A {}"]));
+    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource([
+        "library lib;",
+        "part 'first.dart';",
+        "part 'second.dart';",
+        "",
+        "class A {}"]));
     addSource("/first.dart", EngineTestCase.createSource(["part of lib;", "class B {}"]));
     addSource("/second.dart", EngineTestCase.createSource(["part of lib;", "class C {}"]));
     LibraryElement element = buildLibrary(librarySource, []);
     JUnitTestCase.assertNotNull(element);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     EngineTestCase.assertLength(2, sourcedUnits);
     assertTypes(element.definingCompilationUnit, ["A"]);
     if (sourcedUnits[0].name == "first.dart") {
       assertTypes(sourcedUnits[0], ["B"]);
       assertTypes(sourcedUnits[1], ["C"]);
@@ skipping 51 matching lines @@
    * Build the element model for the library whose defining compilation unit has the given source.
    *
    * @param librarySource the source of the defining compilation unit for the library
    * @param expectedErrorCodes the errors that are expected to be found while building the element
    *          model
    * @return the element model that was built for the library
    * @throws Exception if the element model could not be built
    */
   LibraryElement buildLibrary(Source librarySource, List<ErrorCode> expectedErrorCodes) {
     AnalysisContextImpl context = new AnalysisContextImpl();
-    context.sourceFactory = new SourceFactory.con2([new DartUriResolver(DirectoryBasedDartSdk.defaultSdk), new FileUriResolver()]);
+    context.sourceFactory = new SourceFactory.con2([
+        new DartUriResolver(DirectoryBasedDartSdk.defaultSdk),
+        new FileUriResolver()]);
     LibraryResolver resolver = new LibraryResolver(context);
     LibraryElementBuilder builder = new LibraryElementBuilder(resolver);
     Library library = resolver.createLibrary(librarySource) as Library;
     LibraryElement element = builder.buildLibrary(library);
     GatheringErrorListener listener = new GatheringErrorListener();
     listener.addAll(resolver.errorListener);
     listener.assertErrors2(expectedErrorCodes);
     return element;
   }
   static dartSuite() {
@@ skipping 113 matching lines @@
   ScopeTest_TestScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
   }
   LibraryElement get definingLibrary => _definingLibrary;
   AnalysisErrorListener get errorListener => _errorListener;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => localLookup(name, referencingLibrary);
 }
 class SimpleResolverTest extends ResolverTestCase {
   void fail_staticInvocation() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  static int get g => (a,b) => 0;", "}", "class B {", "  f() {", "    A.g(1,0);", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static int get g => (a,b) => 0;",
+        "}",
+        "class B {",
+        "  f() {",
+        "    A.g(1,0);",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2, 3);",
+        "  }",
+        "  void g(a, b, c) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1, 2]);
   }
   void test_argumentResolution_required_tooFew() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void f() {", "    g(1, 2);", "  }", "  void g(a, b, c) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2);",
+        "  }",
+        "  void g(a, b, c) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1]);
   }
   void test_argumentResolution_required_tooMany() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void f() {", "    g(1, 2, 3);", "  }", "  void g(a, b) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2, 3);",
+        "  }",
+        "  void g(a, b) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1, -1]);
   }
   void test_argumentResolution_requiredAndNamed_extra() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void f() {", "    g(1, 2, c: 3, d: 4);", "  }", "  void g(a, b, {c}) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2, c: 3, d: 4);",
+        "  }",
+        "  void g(a, b, {c}) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1, 2, -1]);
   }
   void test_argumentResolution_requiredAndNamed_matching() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void f() {", "    g(1, 2, c: 3);", "  }", "  void g(a, b, {c}) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2, c: 3);",
+        "  }",
+        "  void g(a, b, {c}) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1, 2]);
   }
   void test_argumentResolution_requiredAndNamed_missing() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void f() {", "    g(1, 2, d: 3);", "  }", "  void g(a, b, {c, d}) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2, d: 3);",
+        "  }",
+        "  void g(a, b, {c, d}) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1, 3]);
   }
   void test_argumentResolution_requiredAndPositional_fewer() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void f() {", "    g(1, 2, 3);", "  }", "  void g(a, b, [c, d]) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2, 3);",
+        "  }",
+        "  void g(a, b, [c, d]) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1, 2]);
   }
   void test_argumentResolution_requiredAndPositional_matching() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void f() {", "    g(1, 2, 3, 4);", "  }", "  void g(a, b, [c, d]) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2, 3, 4);",
+        "  }",
+        "  void g(a, b, [c, d]) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1, 2, 3]);
   }
   void test_argumentResolution_requiredAndPositional_more() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  void f() {", "    g(1, 2, 3, 4);", "  }", "  void g(a, b, [c]) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void f() {",
+        "    g(1, 2, 3, 4);",
+        "  }",
+        "  void g(a, b, [c]) {}",
+        "}"]));
     validateArgumentResolution(source, [0, 1, 2, -1]);
   }
   void test_class_definesCall() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int call(int x) { return x; }", "}", "int f(A a) {", "  return a(0);", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int call(int x) { return x; }",
+        "}",
+        "int f(A a) {",
+        "  return a(0);",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_class_extends_implements() {
-    Source source = addSource(EngineTestCase.createSource(["class A extends B implements C {}", "class B {}", "class C {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A extends B implements C {}",
+        "class B {}",
+        "class C {}"]));
     resolve(source);
     assertNoErrors();
     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() {}", "}"]));
+    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();
     verify([source]);
   }
   void test_commentReference_parameter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "  A.n() {}", "  /** [e] [f] */", "  m(e, f()) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "  A.n() {}",
+        "  /** [e] [f] */",
+        "  m(e, f()) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_commentReference_singleLine() {
     Source source = addSource(EngineTestCase.createSource(["/// [A]", "class A {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_empty() {
     Source source = addSource("");
     resolve(source);
     assertNoErrors();
     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]) {}", "}"]));
+    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();
     verify([source]);
   }
   void test_fieldFormalParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) {}", "}"]));
     resolve(source);
     assertNoErrors();
     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) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  List list = [1,2,3];",
+        "  for (int x in list) {}",
+        "  for (int x in list) {}",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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++) {", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "f() {",
+        "  for (int i = 0; i < 3; i++) {",
+        "  }",
+        "  for (int i = 0; i < 3; i++) {",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_functionTypeAlias() {
-    Source source = addSource(EngineTestCase.createSource(["typedef bool P(e);", "class A {", "  P p;", "  m(e) {", "    if (p(e)) {}", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef bool P(e);",
+        "class A {",
+        "  P p;",
+        "  m(e) {",
+        "    if (p(e)) {}",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();", "}"]));
+    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]);
     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();
     verify([source]);
   }
   void test_import_hide() {
     addSource2("lib1.dart", EngineTestCase.createSource(["library lib1;", "set foo(value) {}"]));
     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;", "}"]));
+    Source source = addSource2("lib3.dart", EngineTestCase.createSource([
+        "import 'lib1.dart' hide foo;",
+        "import 'lib2.dart';",
+        "",
+        "main() {",
+        "  foo = 0;",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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);", "}"]));
+    Source source = addSource2("/one.dart", EngineTestCase.createSource([
+        "library one;",
+        "import 'two.dart' as _two;",
+        "main() {",
+        "  _two.f(0);",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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];", "}"]));
+    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();
     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]);
     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]);", "}"]));
+    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();
     verify([source]);
   }
   void test_invoke_dynamicThroughGetter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  List get X => [() => 0];", "  m(A a) {", "    X.last;", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  List get X => [() => 0];",
+        "  m(A a) {",
+        "    X.last;",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();
     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();
     verify([source]);
   }
   void test_isValidMixin_super() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  toString() {", "    return super.toString();", "  }", "}"]));
+    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();
     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();
     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;", "  }", "}"]));
+    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();
     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;
@@ skipping 36 matching lines @@
     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();
     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();", "}"]));
+    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();
     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();", "}"]));
+    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();
     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();", "  }", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  void m1() {}",
+        "  void m2() {}",
+        "  void m() {",
+        "    A a = new A();",
+        "    a..m1()",
+        "     ..m2();",
+        "  }",
+        "}"]));
     resolve(source);
     assertNoErrors();
     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();", "  }", "}"]));
+    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();
     verify([source]);
   }
   void test_resolveAgainstNull() {
     Source source = addSource(EngineTestCase.createSource(["f(var p) {", "  return null == p;", "}"]));
     resolve(source);
     assertNoErrors();
     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;", "}"]));
+    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();
     verify([source]);
   }
   void test_setter_static() {
     Source source = addSource(EngineTestCase.createSource(["set s(x) {", "}", "", "main() {", "  s = 123;", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
@@ skipping 243 matching lines @@
 //  ErrorResolverTest.dartSuite();
 //  HintCodeTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }