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;", "  });", "}"]);
+    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;", "  }", "}"]));
     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;
@@ skipping 48 matching lines @@
     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;
     ForEachStatement forStatement = body.block.statements[0] as ForEachStatement;
     ReturnStatement statement = ((forStatement.body as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
+  void test_functionExpression_asInvocationArgument() {
+    String code = EngineTestCase.createSource(["class MyMap<K, V> {", "  forEach(f(K key, V value)) {}", "}", "f(MyMap<int, String> m) {", "  m.forEach((k, v) {", "    k;", "    v;", "  });", "}"]);
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors();
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    Type2 intType = typeProvider.intType;
+    FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
+    JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
+    SimpleIdentifier kIdentifier = EngineTestCase.findNode(unit, code, "k;", SimpleIdentifier);
+    JUnitTestCase.assertSame(intType, kIdentifier.propagatedType);
+    JUnitTestCase.assertSame(typeProvider.dynamicType, kIdentifier.staticType);
+    Type2 stringType = typeProvider.stringType;
+    FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
+    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
+    SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
+    JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
+    JUnitTestCase.assertSame(typeProvider.dynamicType, vIdentifier.staticType);
+  }
+  void test_functionExpression_asInvocationArgument_fromInferredInvocation() {
+    String code = EngineTestCase.createSource(["class MyMap<K, V> {", "  forEach(f(K key, V value)) {}", "}", "f(MyMap<int, String> m) {", "  var m2 = m;", "  m2.forEach((k, v) {});", "}"]);
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors();
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    Type2 intType = typeProvider.intType;
+    FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
+    JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
+    Type2 stringType = typeProvider.stringType;
+    FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
+    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
+  }
+  void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
+    String code = EngineTestCase.createSource(["class MyList {", "  forEach(f(Object value)) {}", "}", "f(MyList list) {", "  list.forEach((int v) {", "    v;", "  });", "}"]);
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors();
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    Type2 intType = typeProvider.intType;
+    FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
+    JUnitTestCase.assertSame(null, vParameter.identifier.propagatedType);
+    JUnitTestCase.assertSame(intType, vParameter.identifier.staticType);
+    SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
+    JUnitTestCase.assertSame(intType, vIdentifier.staticType);
+    JUnitTestCase.assertSame(null, vIdentifier.propagatedType);
+  }
+  void test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() {
+    String code = EngineTestCase.createSource(["class MyList<E> {", "  forEach(f(E value)) {}", "}", "f(MyList<String> list) {", "  list.forEach((Object v) {", "    v;", "  });", "}"]);
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors();
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    Type2 stringType = typeProvider.stringType;
+    FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
+    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
+    JUnitTestCase.assertSame(typeProvider.objectType, vParameter.identifier.staticType);
+    SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
+    JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
+  }
+  void test_Future_then() {
+    String code = EngineTestCase.createSource(["import 'dart:async';", "main(Future<int> firstFuture) {", "  firstFuture.then((p1) {", "    return 1.0;", "  }).then((p2) {", "    return new Future<String>.value('str');", "  }).then((p3) {", "  });", "}"]);
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors();
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    FormalParameter p1 = EngineTestCase.findNode(unit, code, "p1) {", SimpleFormalParameter);
+    JUnitTestCase.assertSame(typeProvider.intType, p1.identifier.propagatedType);
+    FormalParameter p2 = EngineTestCase.findNode(unit, code, "p2) {", SimpleFormalParameter);
+    JUnitTestCase.assertSame(typeProvider.doubleType, p2.identifier.propagatedType);
+    FormalParameter p3 = EngineTestCase.findNode(unit, code, "p3) {", SimpleFormalParameter);
+    JUnitTestCase.assertSame(typeProvider.stringType, p3.identifier.propagatedType);
+  }
   void test_initializer() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 0;", "  return v;", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     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 variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
+    NodeList<Statement> statements = body.block.statements;
+    {
+      VariableDeclarationStatement statement = statements[0] as VariableDeclarationStatement;
+      SimpleIdentifier variableName = statement.variables.variables[0].name;
+      JUnitTestCase.assertSame(typeProvider.dynamicType, variableName.staticType);
+      JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
+    }
+    {
+      ReturnStatement statement = statements[1] as ReturnStatement;
+      SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
+      JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
+    }
   }
   void test_initializer_dereference() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 'String';", "  v.", "}"]));
     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;
@@ skipping 237 matching lines @@
     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();", "}"]);
+    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();", "}"]);
+    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();", "}"]);
+    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];", "}"]));
     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);
     JUnitTestCase.assertEquals("BodyElement", elements[2].propagatedType.name);
     JUnitTestCase.assertEquals("ButtonElement", elements[3].propagatedType.name);
     JUnitTestCase.assertEquals("DivElement", elements[4].propagatedType.name);
     JUnitTestCase.assertEquals("InputElement", elements[5].propagatedType.name);
     JUnitTestCase.assertEquals("SelectElement", elements[6].propagatedType.name);
     JUnitTestCase.assertEquals("DivElement", elements[7].propagatedType.name);
     JUnitTestCase.assertEquals("Element", elements[8].propagatedType.name);
     JUnitTestCase.assertEquals("Element", elements[9].propagatedType.name);
     JUnitTestCase.assertEquals("Element", elements[10].propagatedType.name);
   }
+
+  /**
+   * @param code the code that assigns the value to the variable "v", no matter how. We check that
+   *          "v" has expected static and propagated type.
+   */
+  void check_propagatedReturnType(String code, Type2 expectedStaticType, Type2 expectedPropagatedType) {
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors();
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v = ", SimpleIdentifier);
+    JUnitTestCase.assertSame(expectedStaticType, identifier.staticType);
+    JUnitTestCase.assertSame(expectedPropagatedType, identifier.propagatedType);
+  }
   static dartSuite() {
     _ut.group('TypePropagationTest', () {
+      _ut.test('test_Future_then', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_Future_then);
+      });
       _ut.test('test_as', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_as);
       });
       _ut.test('test_assert', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_assert);
       });
       _ut.test('test_assignment', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_assignment);
       });
       _ut.test('test_assignment_afterInitializer', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_assignment_afterInitializer);
       });
       _ut.test('test_forEach', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_forEach);
       });
+      _ut.test('test_functionExpression_asInvocationArgument', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument);
+      });
+      _ut.test('test_functionExpression_asInvocationArgument_fromInferredInvocation', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_fromInferredInvocation);
+      });
+      _ut.test('test_functionExpression_asInvocationArgument_keepIfLessSpecific', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_keepIfLessSpecific);
+      });
+      _ut.test('test_functionExpression_asInvocationArgument_replaceIfMoreSpecific', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_replaceIfMoreSpecific);
+      });
       _ut.test('test_initializer', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_initializer);
       });
       _ut.test('test_initializer_dereference', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_initializer_dereference);
       });
       _ut.test('test_isNot_conditional', () {
         final __test = new TypePropagationTest();
@@ skipping 56 matching lines @@
         runJUnitTest(__test, __test.test_listLiteral_same);
       });
       _ut.test('test_mapLiteral_different', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_mapLiteral_different);
       });
       _ut.test('test_mapLiteral_same', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_mapLiteral_same);
       });
+      _ut.test('test_propagatedReturnType_function_hasReturnType_returnsNull', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_propagatedReturnType_function_hasReturnType_returnsNull);
+      });
+      _ut.test('test_propagatedReturnType_function_lessSpecificStaticReturnType', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_propagatedReturnType_function_lessSpecificStaticReturnType);
+      });
+      _ut.test('test_propagatedReturnType_function_moreSpecificStaticReturnType', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_propagatedReturnType_function_moreSpecificStaticReturnType);
+      });
+      _ut.test('test_propagatedReturnType_function_noReturnTypeName_blockBody_multipleReturns', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_propagatedReturnType_function_noReturnTypeName_blockBody_multipleReturns);
+      });
+      _ut.test('test_propagatedReturnType_function_noReturnTypeName_blockBody_oneReturn', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_propagatedReturnType_function_noReturnTypeName_blockBody_oneReturn);
+      });
+      _ut.test('test_propagatedReturnType_function_noReturnTypeName_expressionBody', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_propagatedReturnType_function_noReturnTypeName_expressionBody);
+      });
+      _ut.test('test_propagatedReturnType_localFunction', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_propagatedReturnType_localFunction);
+      });
       _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';"]));
@@ skipping 169 matching lines @@
     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;}", "}"]));
     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;"]));
+    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;", "}"]));
     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;", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 243 matching lines @@
     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() {", "  }", "}"]));
+    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;", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 124 matching lines @@
     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();", "}"]));
+    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_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) {}", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 364 matching lines @@
     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 {", "  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();", "}"]));
     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;", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 16 matching lines @@
     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>(); }"]));
     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();", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_explicit_unnamed() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B extends A {", "  B() : super();", "}"]));
     resolve(source);
     assertNoErrors();
@@ skipping 51 matching lines @@
     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();", "}"]));
     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;", "}"]));
     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;", "}"]));
     resolve(source);
     assertNoErrors();
   }
+  void test_undefinedSuperMethod_field() {
+    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();", "  }", "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_wrongNumberOfParametersForOperator_index() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator []=(a, b) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_wrongNumberOfParametersForOperator_minus() {
     check_wrongNumberOfParametersForOperator("-", "");
     check_wrongNumberOfParametersForOperator("-", "a");
   }
@@ skipping 149 matching lines @@
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_syntheticField);
       });
       _ut.test('test_constEvalTypeBoolNumString_equal', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constEvalTypeBoolNumString_equal);
       });
       _ut.test('test_constEvalTypeBoolNumString_notEqual', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constEvalTypeBoolNumString_notEqual);
       });
+      _ut.test('test_constEval_propertyExtraction_fieldStatic_targetType', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_constEval_propertyExtraction_fieldStatic_targetType);
+      });
+      _ut.test('test_constEval_propertyExtraction_methodStatic_targetType', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_constEval_propertyExtraction_methodStatic_targetType);
+      });
       _ut.test('test_constWithNonConstantArgument_literals', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constWithNonConstantArgument_literals);
       });
       _ut.test('test_constWithTypeParameters_direct', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constWithTypeParameters_direct);
       });
       _ut.test('test_constWithUndefinedConstructor', () {
         final __test = new NonErrorResolverTest();
@@ skipping 144 matching lines @@
         runJUnitTest(__test, __test.test_importOfNonLibrary_libraryNotDeclared);
       });
       _ut.test('test_inconsistentCaseExpressionTypes', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_inconsistentCaseExpressionTypes);
       });
       _ut.test('test_initializingFormalForNonExistantField', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_initializingFormalForNonExistantField);
       });
+      _ut.test('test_instanceMemberAccessFromStatic_fromComment', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_fromComment);
+      });
       _ut.test('test_invalidAssignment', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidAssignment);
       });
       _ut.test('test_invalidAssignment_compoundAssignment', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidAssignment_compoundAssignment);
       });
       _ut.test('test_invalidAssignment_toDynamic', () {
         final __test = new NonErrorResolverTest();
@@ skipping 64 matching lines @@
         runJUnitTest(__test, __test.test_invalidReferenceToThis_instanceMethod);
       });
       _ut.test('test_invalidTypeArgumentInConstList', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidTypeArgumentInConstList);
       });
       _ut.test('test_invalidTypeArgumentInConstMap', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidTypeArgumentInConstMap);
       });
+      _ut.test('test_invocationOfNonFunction_Object', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invocationOfNonFunction_Object);
+      });
       _ut.test('test_invocationOfNonFunction_dynamic', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invocationOfNonFunction_dynamic);
       });
       _ut.test('test_invocationOfNonFunction_getter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invocationOfNonFunction_getter);
       });
       _ut.test('test_invocationOfNonFunction_localVariable', () {
         final __test = new NonErrorResolverTest();
         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_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 236 matching lines @@
         runJUnitTest(__test, __test.test_returnOfInvalidType_void);
       });
       _ut.test('test_returnWithoutValue_noReturnType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_returnWithoutValue_noReturnType);
       });
       _ut.test('test_returnWithoutValue_void', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_returnWithoutValue_void);
       });
+      _ut.test('test_staticAccessToInstanceMember_annotation', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_staticAccessToInstanceMember_annotation);
+      });
       _ut.test('test_staticAccessToInstanceMember_method', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_method);
       });
       _ut.test('test_staticAccessToInstanceMember_propertyAccess_field', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_propertyAccess_field);
       });
       _ut.test('test_staticAccessToInstanceMember_propertyAccess_propertyAccessor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_propertyAccess_propertyAccessor);
       });
       _ut.test('test_superInInvalidContext', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_superInInvalidContext);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_const', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_new', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
       });
+      _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_0', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_0);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_1', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_1);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_20', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_20);
+      });
       _ut.test('test_undefinedConstructorInInitializer_explicit_named', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_named);
       });
       _ut.test('test_undefinedConstructorInInitializer_explicit_unnamed', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_unnamed);
       });
       _ut.test('test_undefinedConstructorInInitializer_hasOptionalParameters', () {
         final __test = new NonErrorResolverTest();
@@ skipping 28 matching lines @@
         runJUnitTest(__test, __test.test_undefinedIdentifier_hide);
       });
       _ut.test('test_undefinedIdentifier_noSuchMethod', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_noSuchMethod);
       });
       _ut.test('test_undefinedIdentifier_show', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_show);
       });
+      _ut.test('test_undefinedMethod_functionExpression_callMethod', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_undefinedMethod_functionExpression_callMethod);
+      });
+      _ut.test('test_undefinedMethod_functionExpression_directCall', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_undefinedMethod_functionExpression_directCall);
+      });
       _ut.test('test_undefinedMethod_noSuchMethod', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedMethod_noSuchMethod);
       });
       _ut.test('test_undefinedOperator_index', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedOperator_index);
       });
       _ut.test('test_undefinedOperator_tilde', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedOperator_tilde);
       });
       _ut.test('test_undefinedSetter_noSuchMethod', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedSetter_noSuchMethod);
       });
+      _ut.test('test_undefinedSuperMethod_field', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_undefinedSuperMethod_field);
+      });
+      _ut.test('test_undefinedSuperMethod_method', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_undefinedSuperMethod_method);
+      });
       _ut.test('test_wrongNumberOfParametersForOperator1', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator1);
       });
       _ut.test('test_wrongNumberOfParametersForOperator_index', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator_index);
       });
       _ut.test('test_wrongNumberOfParametersForOperator_minus', () {
         final __test = new NonErrorResolverTest();
@@ skipping 27 matching lines @@
    * The library used by the tests.
    */
   Library _library5;
   void setUp() {
     _sourceFactory = new SourceFactory.con2([new FileUriResolver()]);
     _analysisContext = new AnalysisContextImpl();
     _analysisContext.sourceFactory = _sourceFactory;
     _errorListener = new GatheringErrorListener();
     _library5 = library("/lib.dart");
   }
-  void test_addExport() {
-    Library exportLibrary = library("/exported.dart");
-    _library5.addExport(ASTFactory.exportDirective2("exported.dart", []), exportLibrary);
-    List<Library> exports = _library5.exports;
-    EngineTestCase.assertLength(1, exports);
-    JUnitTestCase.assertSame(exportLibrary, exports[0]);
-    _errorListener.assertNoErrors();
-  }
-  void test_addImport() {
-    Library importLibrary = library("/imported.dart");
-    _library5.addImport(ASTFactory.importDirective2("imported.dart", null, []), importLibrary);
-    List<Library> imports = _library5.imports;
-    EngineTestCase.assertLength(1, imports);
-    JUnitTestCase.assertSame(importLibrary, imports[0]);
-    _errorListener.assertNoErrors();
-  }
   void test_getExplicitlyImportsCore() {
     JUnitTestCase.assertFalse(_library5.explicitlyImportsCore);
     _errorListener.assertNoErrors();
   }
-  void test_getExport() {
-    ExportDirective directive = ASTFactory.exportDirective2("exported.dart", []);
-    Library exportLibrary = library("/exported.dart");
-    _library5.addExport(directive, exportLibrary);
-    JUnitTestCase.assertSame(exportLibrary, _library5.getExport(directive));
-    _errorListener.assertNoErrors();
-  }
   void test_getExports() {
     EngineTestCase.assertLength(0, _library5.exports);
     _errorListener.assertNoErrors();
   }
-  void test_getImport() {
-    ImportDirective directive = ASTFactory.importDirective2("imported.dart", null, []);
-    Library importLibrary = library("/imported.dart");
-    _library5.addImport(directive, importLibrary);
-    JUnitTestCase.assertSame(importLibrary, _library5.getImport(directive));
-    _errorListener.assertNoErrors();
-  }
   void test_getImports() {
     EngineTestCase.assertLength(0, _library5.imports);
     _errorListener.assertNoErrors();
   }
   void test_getImportsAndExports() {
-    _library5.addImport(ASTFactory.importDirective2("imported.dart", null, []), library("/imported.dart"));
-    _library5.addExport(ASTFactory.exportDirective2("exported.dart", []), library("/exported.dart"));
+    _library5.importedLibraries = <Library> [library("/imported.dart")];
+    _library5.exportedLibraries = <Library> [library("/exported.dart")];
     EngineTestCase.assertLength(2, _library5.importsAndExports);
     _errorListener.assertNoErrors();
   }
   void test_getLibraryScope() {
     LibraryElementImpl element = new LibraryElementImpl(_analysisContext, ASTFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     _library5.libraryElement = element;
     JUnitTestCase.assertNotNull(_library5.libraryScope);
     _errorListener.assertNoErrors();
   }
   void test_getLibrarySource() {
     JUnitTestCase.assertNotNull(_library5.librarySource);
   }
   void test_setExplicitlyImportsCore() {
     _library5.explicitlyImportsCore = true;
     JUnitTestCase.assertTrue(_library5.explicitlyImportsCore);
     _errorListener.assertNoErrors();
   }
+  void test_setExportedLibraries() {
+    Library exportLibrary = library("/exported.dart");
+    _library5.exportedLibraries = <Library> [exportLibrary];
+    List<Library> exports = _library5.exports;
+    EngineTestCase.assertLength(1, exports);
+    JUnitTestCase.assertSame(exportLibrary, exports[0]);
+    _errorListener.assertNoErrors();
+  }
+  void test_setImportedLibraries() {
+    Library importLibrary = library("/imported.dart");
+    _library5.importedLibraries = <Library> [importLibrary];
+    List<Library> imports = _library5.imports;
+    EngineTestCase.assertLength(1, imports);
+    JUnitTestCase.assertSame(importLibrary, imports[0]);
+    _errorListener.assertNoErrors();
+  }
   void test_setLibraryElement() {
     LibraryElementImpl element = new LibraryElementImpl(_analysisContext, ASTFactory.libraryIdentifier2(["lib"]));
     _library5.libraryElement = element;
     JUnitTestCase.assertSame(element, _library5.libraryElement);
   }
   Library library(String definingCompilationUnitPath) => new Library(_analysisContext, _errorListener, new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(definingCompilationUnitPath)));
   static dartSuite() {
     _ut.group('LibraryTest', () {
-      _ut.test('test_addExport', () {
-        final __test = new LibraryTest();
-        runJUnitTest(__test, __test.test_addExport);
-      });
-      _ut.test('test_addImport', () {
-        final __test = new LibraryTest();
-        runJUnitTest(__test, __test.test_addImport);
-      });
       _ut.test('test_getExplicitlyImportsCore', () {
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_getExplicitlyImportsCore);
       });
-      _ut.test('test_getExport', () {
-        final __test = new LibraryTest();
-        runJUnitTest(__test, __test.test_getExport);
-      });
       _ut.test('test_getExports', () {
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_getExports);
       });
-      _ut.test('test_getImport', () {
-        final __test = new LibraryTest();
-        runJUnitTest(__test, __test.test_getImport);
-      });
       _ut.test('test_getImports', () {
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_getImports);
       });
       _ut.test('test_getImportsAndExports', () {
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_getImportsAndExports);
       });
       _ut.test('test_getLibraryScope', () {
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_getLibraryScope);
       });
       _ut.test('test_getLibrarySource', () {
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_getLibrarySource);
       });
       _ut.test('test_setExplicitlyImportsCore', () {
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_setExplicitlyImportsCore);
       });
+      _ut.test('test_setExportedLibraries', () {
+        final __test = new LibraryTest();
+        runJUnitTest(__test, __test.test_setExportedLibraries);
+      });
+      _ut.test('test_setImportedLibraries', () {
+        final __test = new LibraryTest();
+        runJUnitTest(__test, __test.test_setImportedLibraries);
+      });
       _ut.test('test_setLibraryElement', () {
         final __test = new LibraryTest();
         runJUnitTest(__test, __test.test_setLibraryElement);
       });
     });
   }
 }
 class StaticTypeWarningCodeTest extends ResolverTestCase {
   void fail_inaccessibleSetter() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.INACCESSIBLE_SETTER]);
     verify([source]);
   }
-  void fail_nonTypeAsTypeArgument() {
-    Source source = addSource(EngineTestCase.createSource(["int A;", "class B<E> {}", "f(B<A> b) {}"]));
-    resolve(source);
-    assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
-    verify([source]);
-  }
   void fail_redirectWithInvalidTypeParameters() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.REDIRECT_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
-  void fail_typeArgumentViolatesBounds() {
-    Source source = addSource(EngineTestCase.createSource([]));
-    resolve(source);
-    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_VIOLATES_BOUNDS]);
-    verify([source]);
-  }
   void test_inconsistentMethodInheritance_paramCount() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  int x();", "}", "abstract class B {", "  int x(int y);", "}", "class C implements A, B {", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
     verify([source]);
   }
   void test_inconsistentMethodInheritance_paramType() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  x(int i);", "}", "abstract class B {", "  x(String s);", "}", "abstract class C implements A, B {}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
@@ skipping 85 matching lines @@
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]);
     verify([source]);
   }
   void test_nonBoolExpression() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  assert(0);", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
     verify([source]);
   }
+  void test_nonTypeAsTypeArgument_notAType() {
+    Source source = addSource(EngineTestCase.createSource(["int A;", "class B<E> {}", "f(B<A> b) {}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
+    verify([source]);
+  }
+  void test_nonTypeAsTypeArgument_undefinedIdentifier() {
+    Source source = addSource(EngineTestCase.createSource(["class B<E> {}", "f(B<A> b) {}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
+    verify([source]);
+  }
   void test_returnOfInvalidType_expressionFunctionBody_function() {
     Source source = addSource(EngineTestCase.createSource(["int f() => '0';"]));
     resolve(source);
     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]);
@@ skipping 40 matching lines @@
     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;"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
   void test_typeArgumentNotMatchingBounds_const() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {", "  const G();", "}", "f() { return const G<B>(); }"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
+  void test_typeArgumentNotMatchingBounds_extends() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C extends G<B>{}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_fieldFormalParameter() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C {", "  var f;", "  C(G<B> this.f) {}", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_functionReturnType() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "G<B> f() {}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_functionTypeAlias() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "typedef G<B> f();"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_functionTypedFormalParameter() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "f(G<B> h()) {}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_implements() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C implements G<B>{}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_is() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "var b = 1 is G<B>;"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_methodReturnType() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C {", "  G<B> m() {}", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
   void test_typeArgumentNotMatchingBounds_new() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "f() { return new G<B>(); }"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
+  void test_typeArgumentNotMatchingBounds_new_superTypeOfUpperBound() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {}", "class C extends B {}", "class G<E extends B> {}", "f() { return new G<A>(); }"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_parameter() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "f(G<B> g) {}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_typeArgumentList() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class C<E> {}", "class D<E extends A> {}", "C<D<B>> Var;"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_typeParameter() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class C {}", "class G<E extends A> {}", "class D<F extends G<B>> {}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_variableDeclaration() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "G<B> g;"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_with() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class G<E extends A> {}", "class C extends Object with G<B>{}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+    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]);
   }
@@ skipping 52 matching lines @@
     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>;", "}"]));
+    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>;", "}"]));
+    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);
       });
       _ut.test('test_inconsistentMethodInheritance_paramType', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_inconsistentMethodInheritance_paramType);
       });
@@ skipping 54 matching lines @@
         runJUnitTest(__test, __test.test_nonBoolCondition_if);
       });
       _ut.test('test_nonBoolCondition_while', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_nonBoolCondition_while);
       });
       _ut.test('test_nonBoolExpression', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_nonBoolExpression);
       });
+      _ut.test('test_nonTypeAsTypeArgument_notAType', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_nonTypeAsTypeArgument_notAType);
+      });
+      _ut.test('test_nonTypeAsTypeArgument_undefinedIdentifier', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_nonTypeAsTypeArgument_undefinedIdentifier);
+      });
       _ut.test('test_returnOfInvalidType_expressionFunctionBody_function', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_returnOfInvalidType_expressionFunctionBody_function);
       });
       _ut.test('test_returnOfInvalidType_expressionFunctionBody_getter', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_returnOfInvalidType_expressionFunctionBody_getter);
       });
       _ut.test('test_returnOfInvalidType_expressionFunctionBody_localFunction', () {
         final __test = new StaticTypeWarningCodeTest();
@@ skipping 20 matching lines @@
         runJUnitTest(__test, __test.test_returnOfInvalidType_localFunction);
       });
       _ut.test('test_returnOfInvalidType_method', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_returnOfInvalidType_method);
       });
       _ut.test('test_returnOfInvalidType_void', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_returnOfInvalidType_void);
       });
+      _ut.test('test_typeArgumentNotMatchingBounds_classTypeAlias', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_classTypeAlias);
+      });
       _ut.test('test_typeArgumentNotMatchingBounds_const', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
       });
+      _ut.test('test_typeArgumentNotMatchingBounds_extends', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_extends);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_fieldFormalParameter', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_fieldFormalParameter);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_functionReturnType', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_functionReturnType);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_functionTypeAlias', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_functionTypeAlias);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_functionTypedFormalParameter', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_functionTypedFormalParameter);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_implements', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_implements);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_is', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_is);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_methodReturnType', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_methodReturnType);
+      });
       _ut.test('test_typeArgumentNotMatchingBounds_new', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
       });
+      _ut.test('test_typeArgumentNotMatchingBounds_new_superTypeOfUpperBound', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new_superTypeOfUpperBound);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_parameter', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_parameter);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_typeParameter', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeParameter);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_variableDeclaration', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_variableDeclaration);
+      });
+      _ut.test('test_typeArgumentNotMatchingBounds_with', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_with);
+      });
       _ut.test('test_undefinedFunction', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedFunction);
       });
       _ut.test('test_undefinedGetter', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedGetter);
       });
       _ut.test('test_undefinedGetter_static', () {
         final __test = new StaticTypeWarningCodeTest();
@@ skipping 36 matching lines @@
         runJUnitTest(__test, __test.test_undefinedSuperMethod);
       });
       _ut.test('test_wrongNumberOfTypeArguments_tooFew', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_tooFew);
       });
       _ut.test('test_wrongNumberOfTypeArguments_tooMany', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_tooMany);
       });
+      _ut.test('test_wrongNumberOfTypeArguments_typeTest_tooFew', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_typeTest_tooFew);
+      });
+      _ut.test('test_wrongNumberOfTypeArguments_typeTest_tooMany', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_typeTest_tooMany);
+      });
     });
   }
 }
 class TypeResolverVisitorTest extends EngineTestCase {
 
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
@@ skipping 193 matching lines @@
     TypeName typeName = ASTFactory.typeName4("void", []);
     resolveNode(typeName, [classA]);
     JUnitTestCase.assertSame(VoidTypeImpl.instance, typeName.type);
     _listener.assertNoErrors();
   }
 
   /**
    * Analyze the given catch clause and assert that the types of the parameters have been set to the
    * given types. The types can be null if the catch clause does not have the corresponding
    * parameter.
+   *
    * @param node the catch clause to be analyzed
    * @param exceptionType the expected type of the exception parameter
    * @param stackTraceType the expected type of the stack trace parameter
    * @param definedElements the elements that are to be defined in the scope in which the element is
-   * being resolved
+   *          being resolved
    */
   void resolve(CatchClause node, InterfaceType exceptionType, InterfaceType stackTraceType, List<Element> definedElements) {
     resolveNode(node, definedElements);
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       JUnitTestCase.assertSame(exceptionType, exceptionParameter.staticType);
     }
     SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
     if (stackTraceParameter != null) {
       JUnitTestCase.assertSame(stackTraceType, stackTraceParameter.staticType);
     }
   }
 
   /**
    * Return the type associated with the given parameter after the static type analyzer has computed
    * a type for it.
+   *
    * @param node the parameter with which the type is associated
    * @param definedElements the elements that are to be defined in the scope in which the element is
-   * being resolved
+   *          being resolved
    * @return the type associated with the parameter
    */
   Type2 resolve6(FormalParameter node, List<Element> definedElements) {
     resolveNode(node, definedElements);
     return ((node.identifier.element as ParameterElement)).type;
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
+   *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
-   * being resolved
+   *          being resolved
    * @return the element to which the expression was resolved
    */
   void resolveNode(ASTNode node, List<Element> definedElements) {
     for (Element element in definedElements) {
       _library.libraryScope.define(element);
     }
     node.accept(_visitor);
   }
   static dartSuite() {
     _ut.group('TypeResolverVisitorTest', () {
@@ skipping 44 matching lines @@
       _ut.test('test_visitTypeName_void', () {
         final __test = new TypeResolverVisitorTest();
         runJUnitTest(__test, __test.test_visitTypeName_void);
       });
     });
   }
 }
 class ResolverTestCase extends EngineTestCase {
 
   /**
-   * The source factory used to create [Source sources].
+   * The source factory used to create [Source].
    */
   SourceFactory _sourceFactory;
 
   /**
    * The analysis context used to parse the compilation units being resolved.
    */
   AnalysisContextImpl _analysisContext;
   void setUp() {
     reset();
   }
 
   /**
    * Add a source file to the content provider.
+   *
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource(String contents) => addSource2("/test.dart", contents);
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
+   *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource2(String filePath, String contents) {
     Source source = cacheSource(filePath, contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.added(source);
     _analysisContext.applyChanges(changeSet);
     return source;
   }
 
   /**
    * Assert that the number of errors that have been gathered matches the number of errors that are
    * given and that they have the expected error codes. The order in which the errors were gathered
    * is ignored.
+   *
    * @param expectedErrorCodes the error codes of the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
-   * expected
+   *           expected
    */
   void assertErrors(List<ErrorCode> expectedErrorCodes) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     for (ChangeNotice notice in _analysisContext.performAnalysisTask()) {
       for (AnalysisError error in notice.errors) {
         errorListener.onError(error);
       }
     }
     errorListener.assertErrors2(expectedErrorCodes);
   }
 
   /**
    * Assert that no errors have been gathered.
+   *
    * @throws AssertionFailedError if any errors have been gathered
    */
   void assertNoErrors() {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     for (ChangeNotice notice in _analysisContext.performAnalysisTask()) {
       for (AnalysisError error in notice.errors) {
         errorListener.onError(error);
       }
     }
     errorListener.assertNoErrors();
   }
 
   /**
    * Cache the source file content in the source factory but don't add the source to the analysis
    * context. The file path should be absolute.
+   *
    * @param filePath the path of the file being cached
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the cached file
    */
   Source cacheSource(String filePath, String contents) {
     Source source = new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(filePath));
     _sourceFactory.setContents(source, contents);
     return source;
   }
 
   /**
    * Create a library element that represents a library named `"test"` containing a single
    * empty compilation unit.
+   *
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary() => createTestLibrary2(new AnalysisContextImpl(), "test", []);
 
   /**
    * Create a library element that represents a library with the given name containing a single
    * empty compilation unit.
+   *
    * @param libraryName the name of the library to be created
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary2(AnalysisContext context, String libraryName, List<String> typeNames) {
     int count = typeNames.length;
     List<CompilationUnitElementImpl> sourcedCompilationUnits = new List<CompilationUnitElementImpl>(count);
     for (int i = 0; i < count; i++) {
       String typeName = typeNames[i];
       ClassElementImpl type = new ClassElementImpl(ASTFactory.identifier3(typeName));
       String fileName = "${typeName}.dart";
       CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
       compilationUnit.source = createSource2(fileName);
       compilationUnit.types = <ClassElement> [type];
       sourcedCompilationUnits[i] = compilationUnit;
     }
     String fileName = "${libraryName}.dart";
     CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
     compilationUnit.source = createSource2(fileName);
     LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = compilationUnit;
     library.parts = sourcedCompilationUnits;
     return library;
   }
   AnalysisContext get analysisContext => _analysisContext;
   SourceFactory get sourceFactory => _sourceFactory;
 
   /**
    * Return a type provider that can be used to test the results of resolution.
+   *
    * @return a type provider
    */
   TypeProvider get typeProvider {
     Source coreSource = _analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
     LibraryElement coreElement = _analysisContext.getLibraryElement(coreSource);
     return new TypeProviderImpl(coreElement);
   }
 
   /**
    * In the rare cases we want to group several tests into single "test_" method, so need a way to
    * reset test instance to reuse it.
    */
   void reset() {
     _analysisContext = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _analysisContext.sourceFactory;
   }
 
   /**
    * Given a library and all of its parts, resolve the contents of the library and the contents of
    * the parts. This assumes that the sources for the library and its parts have already been added
    * to the content provider using the method [addSource].
+   *
    * @param librarySource the source for the compilation unit that defines the library
    * @return the element representing the resolved library
    * @throws AnalysisException if the analysis could not be performed
    */
   LibraryElement resolve(Source librarySource) => _analysisContext.computeLibraryElement(librarySource);
 
   /**
    * Return the resolved compilation unit corresponding to the given source in the given library.
+   *
    * @param source the source of the compilation unit to be returned
    * @param library the library in which the compilation unit is to be resolved
    * @return the resolved compilation unit
    * @throws Exception if the compilation unit could not be resolved
    */
   CompilationUnit resolveCompilationUnit(Source source, LibraryElement library) => _analysisContext.resolveCompilationUnit(source, library);
 
   /**
    * Verify that all of the identifiers in the compilation units associated with the given sources
    * have been resolved.
+   *
    * @param resolvedElementMap a table mapping the AST nodes that have been resolved to the element
-   * to which they were resolved
+   *          to which they were resolved
    * @param sources the sources identifying the compilation units to be verified
    * @throws Exception if the contents of the compilation unit cannot be accessed
    */
   void verify(List<Source> sources) {
     ResolutionVerifier verifier = new ResolutionVerifier();
     for (Source source in sources) {
       _analysisContext.parseCompilationUnit(source).accept(verifier);
     }
     verifier.assertResolved();
   }
 
   /**
    * Create a source object representing a file with the given name and give it an empty content.
+   *
    * @param fileName the name of the file for which a source is to be created
    * @return the source that was created
    */
   FileBasedSource createSource2(String fileName) {
     FileBasedSource source = new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(fileName));
     _sourceFactory.setContents(source, "");
     return source;
   }
   static dartSuite() {
     _ut.group('ResolverTestCase', () {
     });
   }
 }
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
     InterfaceType objectType = classElement("Object", null, []).type;
     InterfaceType boolType = classElement("bool", objectType, []).type;
     InterfaceType numType = classElement("num", objectType, []).type;
     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, 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);
     JUnitTestCase.assertSame(mapType, provider.mapType);
     JUnitTestCase.assertSame(objectType, provider.objectType);
     JUnitTestCase.assertSame(stackTraceType, provider.stackTraceType);
     JUnitTestCase.assertSame(stringType, provider.stringType);
+    JUnitTestCase.assertSame(symbolType, provider.symbolType);
     JUnitTestCase.assertSame(typeType, provider.typeType);
   }
   ClassElement classElement(String typeName, InterfaceType superclassType, List<String> parameterNames) {
     ClassElementImpl element = new ClassElementImpl(ASTFactory.identifier3(typeName));
     element.supertype = superclassType;
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(element);
     element.type = type;
     int count = parameterNames.length;
     if (count > 0) {
       List<TypeVariableElementImpl> typeVariables = new List<TypeVariableElementImpl>(count);
@@ skipping 332 matching lines @@
       }
     }
     errorListener.assertErrors2(expectedErrorCodes);
   }
   void assertNoErrors(ClassElement classElt) {
     assertErrors(classElt, []);
   }
 
   /**
    * Create the inheritance manager used by the tests.
+   *
    * @return the inheritance manager that was created
    */
   InheritanceManager createInheritanceManager() {
     AnalysisContextImpl context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source = new FileBasedSource.con1(new ContentCache(), FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     return new InheritanceManager(_definingLibrary);
@@ skipping 121 matching lines @@
     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(); }"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION]);
     verify([source]);
   }
-  void fail_duplicateDefinition() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  int m = 0;", "  m(a) {}", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
-    verify([source]);
-  }
-  void fail_duplicateMemberError_classMembers_fields() {
-    Source librarySource = addSource(EngineTestCase.createSource(["class A {", "  int a;", "  int a;", "}"]));
-    resolve(librarySource);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
-    verify([librarySource]);
-  }
-  void fail_duplicateMemberError_localFields() {
-    Source librarySource = addSource(EngineTestCase.createSource(["class A {", "  m() {", "    int a;", "    int a;", "  }", "}"]));
-    resolve(librarySource);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]);
-    verify([librarySource]);
-  }
-  void fail_duplicateMemberName() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int x = 0;", "  int x() {}", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_MEMBER_NAME]);
-    verify([source]);
-  }
-  void fail_duplicateMemberNameInstanceStatic() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  static int x;", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_MEMBER_NAME_INSTANCE_STATIC]);
-    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_invalidOverrideDefaultValue() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m([a = 0]) {}", "}", "class B extends A {", "  m([a = 1]) {}", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_DEFAULT_VALUE]);
-    verify([source]);
-  }
   void fail_mixinDeclaresConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B extends Object mixin A {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     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]);
@@ skipping 46 matching lines @@
     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 fail_wrongNumberOfTypeArguments_creation_const_tooFew() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {}", "f(p) {", "  return const C<A>();", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
-  }
-  void fail_wrongNumberOfTypeArguments_creation_const_tooMany() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {}", "f(p) {", "  return const C<A, A>();", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
-  }
-  void fail_wrongNumberOfTypeArguments_creation_new_tooFew() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {}", "f(p) {", "  return new C<A>();", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
-  }
-  void fail_wrongNumberOfTypeArguments_creation_new_tooMany() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {}", "f(p) {", "  return new C<A, A>();", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
-  }
-  void fail_wrongNumberOfTypeArguments_typeTest_tooFew() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<K, V> {}", "f(p) {", "  return p is C<A>;", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
-  }
-  void fail_wrongNumberOfTypeArguments_typeTest_tooMany() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class C<E> {}", "f(p) {", "  return p is C<A, A>;", "}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
-  }
   void test_ambiguousExport() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';", "export 'lib2.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
     verify([source]);
   }
   void test_ambiguousImport_as() {
     Source source = addSource(EngineTestCase.createSource(["import 'lib1.dart';", "import 'lib2.dart';", "f(p) {p as N;}"]));
@@ skipping 95 matching lines @@
     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(IntWrapper 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() {}", "}"]));
+    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() {}", "}"]));
+    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;", "}"]));
+    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;", "}"]));
+    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();", "}"]));
     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();", "}"]));
     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;"]));
+    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;"]));
+    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]);
   }
   void test_constEvalThrowsException_unaryNegated_null() {
     Source source = addSource("const C = -null;");
     resolve(source);
     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]);
+    verify([source]);
+  }
   void test_constEvalTypeBoolNumString_equal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "class B {", "  final a;", "  const B(num p) : a = p == const A();", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
     verify([source]);
   }
   void test_constEvalTypeBoolNumString_notEqual() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "class B {", "  final a;", "  const B(String p) : a = p != const A();", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
@@ skipping 53 matching lines @@
     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>(); }"]));
     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>();", "}"]));
+    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>();", "}"]));
+    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); }"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONST]);
     verify([source]);
   }
   void test_constWithNonConstantArgument() {
     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();", "}"]));
+    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();", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_constWithTypeParameters_indirect() {
     Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  static const V = const A<List<T>>();", "  const A();", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS]);
@@ skipping 21 matching lines @@
     resolve(source);
     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]);
     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]);
+    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]);
+    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]);
+    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]);
+    verify([librarySource]);
+  }
+  void test_duplicateDefinition_localFields() {
+    Source librarySource = addSource(EngineTestCase.createSource(["class A {", "  m() {", "    int a;", "    int a;", "  }", "}"]));
+    resolve(librarySource);
+    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]);
     verify([source]);
   }
   void test_duplicateDefinition_parameterWithFunctionName_topLevel() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  f(f) {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
-  void test_duplicateMemberError() {
-    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_duplicateDefinitionInheritance_instanceMethod_staticMethod() {
+    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_duplicateMemberError_classMembers_methods() {
-    Source librarySource = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "  m() {}", "}"]));
-    resolve(librarySource);
-    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION, CompileTimeErrorCode.DUPLICATE_DEFINITION]);
-    verify([librarySource]);
+  void test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod() {
+    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  x();", "}", "abstract class B extends A {", "  static x() {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
+    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_extendsOrImplementsDisallowedClass_extends_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A extends bool {}"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS, StaticWarningCode.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, StaticWarningCode.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, StaticWarningCode.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, StaticWarningCode.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, StaticWarningCode.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 181 matching lines @@
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_REPEATED, CompileTimeErrorCode.IMPLEMENTS_REPEATED, CompileTimeErrorCode.IMPLEMENTS_REPEATED]);
     verify([source]);
   }
   void test_implicitThisReferenceInInitializer_field() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  var v;", "  A() : v = f;", "  var f;", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     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() {}", "}"]));
     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;", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
@@ skipping 64 matching lines @@
     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;", "  }", "}"]));
+    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;", "  }", "}"]));
+    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();", "  }", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
+    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]);
@@ skipping 232 matching lines @@
     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>();", "}"]));
+    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>();", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
+    verify([source]);
+  }
+  void test_noDefaultSuperConstructorExplicit() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  A(p);", "}", "class B extends A {", "  B() {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
+    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_nonConstantDefaultValue_function_named() {
     Source source = addSource(EngineTestCase.createSource(["int y;", "f({x : y}) {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
     verify([source]);
   }
   void test_nonConstantDefaultValue_function_positional() {
     Source source = addSource(EngineTestCase.createSource(["int y;", "f([x = y]) {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
@@ skipping 106 matching lines @@
     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();", "}"]));
     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 {", "}"]));
+    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();", "}"]));
     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]);
@@ skipping 315 matching lines @@
     check_wrongNumberOfParametersForOperator1("~/");
     check_wrongNumberOfParametersForOperator1("*");
     check_wrongNumberOfParametersForOperator1("%");
     check_wrongNumberOfParametersForOperator1("|");
     check_wrongNumberOfParametersForOperator1("^");
     check_wrongNumberOfParametersForOperator1("&");
     check_wrongNumberOfParametersForOperator1("<<");
     check_wrongNumberOfParametersForOperator1(">>");
     check_wrongNumberOfParametersForOperator1("[]");
   }
+  void test_wrongNumberOfParametersForSetter_function_named() {
+    Source source = addSource("set x({p}) {}");
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    verify([source]);
+  }
+  void test_wrongNumberOfParametersForSetter_function_optional() {
+    Source source = addSource("set x([p]) {}");
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    verify([source]);
+  }
   void test_wrongNumberOfParametersForSetter_function_tooFew() {
     Source source = addSource("set x() {}");
     resolve(source);
     assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_function_tooMany() {
     Source source = addSource("set x(a, b) {}");
     resolve(source);
     assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
+  void test_wrongNumberOfParametersForSetter_method_named() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  set x({p}) {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    verify([source]);
+  }
+  void test_wrongNumberOfParametersForSetter_method_optional() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  set x([p]) {}", "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
+    verify([source]);
+  }
   void test_wrongNumberOfParametersForSetter_method_tooFew() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set x() {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void test_wrongNumberOfParametersForSetter_method_tooMany() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  set x(a, b) {}", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
@@ skipping 117 matching lines @@
         runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals);
       });
       _ut.test('test_conflictingConstructorNameAndMember_field', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_conflictingConstructorNameAndMember_field);
       });
       _ut.test('test_conflictingConstructorNameAndMember_method', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_conflictingConstructorNameAndMember_method);
       });
+      _ut.test('test_conflictingGetterAndMethod_field_method', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingGetterAndMethod_field_method);
+      });
+      _ut.test('test_conflictingGetterAndMethod_getter_method', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingGetterAndMethod_getter_method);
+      });
+      _ut.test('test_conflictingGetterAndMethod_method_field', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingGetterAndMethod_method_field);
+      });
+      _ut.test('test_conflictingGetterAndMethod_method_getter', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingGetterAndMethod_method_getter);
+      });
       _ut.test('test_constConstructorWithNonFinalField_mixin', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_mixin);
       });
       _ut.test('test_constConstructorWithNonFinalField_super', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_super);
       });
       _ut.test('test_constConstructorWithNonFinalField_this', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_this);
       });
       _ut.test('test_constEvalThrowsException_binaryMinus_null', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalThrowsException_binaryMinus_null);
       });
       _ut.test('test_constEvalThrowsException_binaryPlus_null', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalThrowsException_binaryPlus_null);
       });
+      _ut.test('test_constEvalThrowsException_divisionByZero', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constEvalThrowsException_divisionByZero);
+      });
       _ut.test('test_constEvalThrowsException_unaryBitNot_null', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalThrowsException_unaryBitNot_null);
       });
       _ut.test('test_constEvalThrowsException_unaryNegated_null', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalThrowsException_unaryNegated_null);
       });
       _ut.test('test_constEvalThrowsException_unaryNot_null', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalThrowsException_unaryNot_null);
       });
       _ut.test('test_constEvalTypeBoolNumString_equal', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalTypeBoolNumString_equal);
       });
       _ut.test('test_constEvalTypeBoolNumString_notEqual', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalTypeBoolNumString_notEqual);
       });
       _ut.test('test_constEvalTypeBool_binary', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalTypeBool_binary);
       });
+      _ut.test('test_constEvalTypeBool_binary_leftTrue', () {
+        final __test = new CompileTimeErrorCodeTest();
+        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_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();
+        runJUnitTest(__test, __test.test_constEval_propertyExtraction_methodStatic_targetInstance);
+      });
       _ut.test('test_constFormalParameter_fieldFormalParameter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constFormalParameter_fieldFormalParameter);
       });
       _ut.test('test_constFormalParameter_simpleFormalParameter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constFormalParameter_simpleFormalParameter);
       });
       _ut.test('test_constInitializedWithNonConstValue', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constInitializedWithNonConstValue);
       });
       _ut.test('test_constInitializedWithNonConstValue_missingConstInListLiteral', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constInitializedWithNonConstValue_missingConstInListLiteral);
       });
       _ut.test('test_constInitializedWithNonConstValue_missingConstInMapLiteral', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constInitializedWithNonConstValue_missingConstInMapLiteral);
       });
       _ut.test('test_constInstanceField', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constInstanceField);
       });
       _ut.test('test_constWithInvalidTypeParameters', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithInvalidTypeParameters);
       });
+      _ut.test('test_constWithInvalidTypeParameters_tooFew', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constWithInvalidTypeParameters_tooFew);
+      });
+      _ut.test('test_constWithInvalidTypeParameters_tooMany', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constWithInvalidTypeParameters_tooMany);
+      });
       _ut.test('test_constWithNonConst', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithNonConst);
       });
       _ut.test('test_constWithNonConstantArgument', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithNonConstantArgument);
       });
       _ut.test('test_constWithNonType', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithNonType);
       });
+      _ut.test('test_constWithNonType_fromLibrary', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constWithNonType_fromLibrary);
+      });
       _ut.test('test_constWithTypeParameters_direct', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithTypeParameters_direct);
       });
       _ut.test('test_constWithTypeParameters_indirect', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithTypeParameters_indirect);
       });
       _ut.test('test_constWithUndefinedConstructor', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithUndefinedConstructor);
       });
       _ut.test('test_constWithUndefinedConstructorDefault', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithUndefinedConstructorDefault);
       });
       _ut.test('test_defaultValueInFunctionTypeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_defaultValueInFunctionTypeAlias);
       });
       _ut.test('test_duplicateConstructorName_named', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateConstructorName_named);
       });
       _ut.test('test_duplicateConstructorName_unnamed', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateConstructorName_unnamed);
       });
+      _ut.test('test_duplicateDefinition', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_duplicateDefinition);
+      });
+      _ut.test('test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod);
+      });
+      _ut.test('test_duplicateDefinitionInheritance_instanceMethod_staticMethod', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_duplicateDefinitionInheritance_instanceMethod_staticMethod);
+      });
+      _ut.test('test_duplicateDefinition_acrossLibraries', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_duplicateDefinition_acrossLibraries);
+      });
+      _ut.test('test_duplicateDefinition_classMembers_fields', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_duplicateDefinition_classMembers_fields);
+      });
+      _ut.test('test_duplicateDefinition_classMembers_fields_oneStatic', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_duplicateDefinition_classMembers_fields_oneStatic);
+      });
+      _ut.test('test_duplicateDefinition_classMembers_methods', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_duplicateDefinition_classMembers_methods);
+      });
+      _ut.test('test_duplicateDefinition_localFields', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_duplicateDefinition_localFields);
+      });
       _ut.test('test_duplicateDefinition_parameterWithFunctionName_local', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateDefinition_parameterWithFunctionName_local);
       });
       _ut.test('test_duplicateDefinition_parameterWithFunctionName_topLevel', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateDefinition_parameterWithFunctionName_topLevel);
       });
-      _ut.test('test_duplicateMemberError', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_duplicateMemberError);
-      });
-      _ut.test('test_duplicateMemberError_classMembers_methods', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_duplicateMemberError_classMembers_methods);
-      });
       _ut.test('test_duplicateNamedArgument', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateNamedArgument);
       });
       _ut.test('test_exportInternalLibrary', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_exportInternalLibrary);
       });
       _ut.test('test_exportOfNonLibrary', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 136 matching lines @@
         runJUnitTest(__test, __test.test_implementsRepeated);
       });
       _ut.test('test_implementsRepeated_3times', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsRepeated_3times);
       });
       _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_redirectingConstructorInvocation', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implicitThisReferenceInInitializer_redirectingConstructorInvocation);
       });
       _ut.test('test_implicitThisReferenceInInitializer_superConstructorInvocation', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 36 matching lines @@
         runJUnitTest(__test, __test.test_initializingFormalForNonExistantField_notInEnclosingClass);
       });
       _ut.test('test_initializingFormalForNonExistantField_optional', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_initializingFormalForNonExistantField_optional);
       });
       _ut.test('test_initializingFormalForNonExistantField_static', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_initializingFormalForNonExistantField_static);
       });
+      _ut.test('test_instanceMemberAccessFromStatic_field', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_field);
+      });
+      _ut.test('test_instanceMemberAccessFromStatic_getter', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_getter);
+      });
+      _ut.test('test_instanceMemberAccessFromStatic_method', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_method);
+      });
       _ut.test('test_invalidConstructorName_notEnclosingClassName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_invalidConstructorName_notEnclosingClassName);
       });
       _ut.test('test_invalidFactoryNameNotAClass_notClassName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_invalidFactoryNameNotAClass_notClassName);
       });
       _ut.test('test_invalidFactoryNameNotAClass_notEnclosingClassName', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 156 matching lines @@
         runJUnitTest(__test, __test.test_nativeFunctionBodyInNonSDKCode_function);
       });
       _ut.test('test_nativeFunctionBodyInNonSDKCode_method', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nativeFunctionBodyInNonSDKCode_method);
       });
       _ut.test('test_newWithInvalidTypeParameters', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_newWithInvalidTypeParameters);
       });
+      _ut.test('test_newWithInvalidTypeParameters_tooFew', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_newWithInvalidTypeParameters_tooFew);
+      });
+      _ut.test('test_newWithInvalidTypeParameters_tooMany', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_newWithInvalidTypeParameters_tooMany);
+      });
+      _ut.test('test_noDefaultSuperConstructorExplicit', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_noDefaultSuperConstructorExplicit);
+      });
+      _ut.test('test_noDefaultSuperConstructorImplicit_superHasParameters', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superHasParameters);
+      });
+      _ut.test('test_noDefaultSuperConstructorImplicit_superOnlyNamed', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superOnlyNamed);
+      });
       _ut.test('test_nonConstCaseExpression', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonConstCaseExpression);
       });
       _ut.test('test_nonConstListElement', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonConstListElement);
       });
       _ut.test('test_nonConstMapAsExpressionStatement_begin', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 64 matching lines @@
         runJUnitTest(__test, __test.test_nonConstantDefaultValue_method_positional);
       });
       _ut.test('test_nonGenerativeConstructor_explicit', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonGenerativeConstructor_explicit);
       });
       _ut.test('test_nonGenerativeConstructor_implicit', () {
         final __test = new CompileTimeErrorCodeTest();
         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_optionalParameterInOperator_named', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_optionalParameterInOperator_named);
       });
       _ut.test('test_optionalParameterInOperator_positional', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 200 matching lines @@
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator1);
       });
       _ut.test('test_wrongNumberOfParametersForOperator_minus', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator_minus);
       });
       _ut.test('test_wrongNumberOfParametersForOperator_tilde', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator_tilde);
       });
+      _ut.test('test_wrongNumberOfParametersForSetter_function_named', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_function_named);
+      });
+      _ut.test('test_wrongNumberOfParametersForSetter_function_optional', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_function_optional);
+      });
       _ut.test('test_wrongNumberOfParametersForSetter_function_tooFew', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_function_tooFew);
       });
       _ut.test('test_wrongNumberOfParametersForSetter_function_tooMany', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_function_tooMany);
       });
+      _ut.test('test_wrongNumberOfParametersForSetter_method_named', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_named);
+      });
+      _ut.test('test_wrongNumberOfParametersForSetter_method_optional', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_optional);
+      });
       _ut.test('test_wrongNumberOfParametersForSetter_method_tooFew', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_tooFew);
       });
       _ut.test('test_wrongNumberOfParametersForSetter_method_tooMany', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_tooMany);
       });
     });
   }
@@ skipping 662 matching lines @@
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = ASTFactory.superConstructorInvocation([ASTFactory.namedExpression2(parameterName, ASTFactory.integer(0))]);
     resolveInClass(invocation, subclass);
     JUnitTestCase.assertEquals(superConstructor, invocation.element);
     JUnitTestCase.assertSame(parameter, ((invocation.argumentList.arguments[0] as NamedExpression)).name.label.element);
     _listener.assertNoErrors();
   }
 
   /**
    * Create the resolver used by the tests.
+   *
    * @return the resolver that was created
    */
   ElementResolver createResolver() {
     AnalysisContextImpl context = new AnalysisContextImpl();
     ContentCache contentCache = new ContentCache();
     SourceFactory sourceFactory = new SourceFactory.con1(contentCache, [new DartUriResolver(DirectoryBasedDartSdk.defaultSdk)]);
     context.sourceFactory = sourceFactory;
     FileBasedSource source = new FileBasedSource.con1(contentCache, FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     Library library = new Library(context, _listener, source);
     library.libraryElement = _definingLibrary;
     _visitor = new ResolverVisitor.con1(library, source, _typeProvider);
     try {
       return _visitor.elementResolver_J2DAccessor as ElementResolver;
     } catch (exception) {
       throw new IllegalArgumentException("Could not create resolver", exception);
     }
   }
 
   /**
    * Return the element associated with the label of the given statement after the resolver has
    * resolved the statement.
+   *
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
    * @return the element to which the statement's label was resolved
    */
   Element resolve(BreakStatement statement, LabelElementImpl labelElement) {
     resolveStatement(statement, labelElement);
     return statement.label.element;
   }
 
   /**
    * Return the element associated with the label of the given statement after the resolver has
    * resolved the statement.
+   *
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
    * @return the element to which the statement's label was resolved
    */
   Element resolve3(ContinueStatement statement, LabelElementImpl labelElement) {
     resolveStatement(statement, labelElement);
     return statement.label.element;
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
+   *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
-   * being resolved
+   *          being resolved
    * @return the element to which the expression was resolved
    */
   Element resolve4(Identifier node, List<Element> definedElements) {
     resolveNode(node, definedElements);
     return node.element;
   }
 
   /**
    * Return the element associated with the given expression after the resolver has resolved the
    * expression.
+   *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
-   * being resolved
+   *          being resolved
    * @return the element to which the expression was resolved
    */
   Element resolve5(IndexExpression node, List<Element> definedElements) {
     resolveNode(node, definedElements);
     return node.element;
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
+   *
    * @param node the expression to be resolved
    * @param enclosingClass the element representing the class enclosing the identifier
    * @return the element to which the expression was resolved
    */
   void resolveInClass(ASTNode node, ClassElement enclosingClass) {
     try {
       Scope outerScope = _visitor.nameScope_J2DAccessor as Scope;
       try {
         _visitor.enclosingClass_J2DAccessor = enclosingClass;
         EnclosedScope innerScope = new ClassScope(outerScope, enclosingClass);
         _visitor.nameScope_J2DAccessor = innerScope;
         node.accept(_resolver);
       } finally {
         _visitor.enclosingClass_J2DAccessor = null;
         _visitor.nameScope_J2DAccessor = outerScope;
       }
     } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
+   *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
-   * being resolved
+   *          being resolved
    * @return the element to which the expression was resolved
    */
   void resolveNode(ASTNode node, List<Element> definedElements) {
     try {
       Scope outerScope = _visitor.nameScope_J2DAccessor as Scope;
       try {
         EnclosedScope innerScope = new EnclosedScope(outerScope);
         for (Element element in definedElements) {
           innerScope.define(element);
         }
         _visitor.nameScope_J2DAccessor = innerScope;
         node.accept(_resolver);
       } finally {
         _visitor.nameScope_J2DAccessor = outerScope;
       }
     } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
 
   /**
    * Return the element associated with the label of the given statement after the resolver has
    * resolved the statement.
+   *
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
    * @return the element to which the statement's label was resolved
    */
   void resolveStatement(Statement statement, LabelElementImpl labelElement) {
     try {
       LabelScope outerScope = _visitor.labelScope_J2DAccessor as LabelScope;
       try {
         LabelScope innerScope;
         if (labelElement == null) {
@@ skipping 466 matching lines @@
     resolve(source);
     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() {}"]));
     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 {", "  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 {", "  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';", "}"]));
     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'];", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
@@ skipping 339 matching lines @@
     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() {}", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC]);
     verify([source]);
   }
   void test_instanceMethodNameCollidesWithSuperclassStatic_setter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int i = 0;", "  static set n(int x) {i = 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 {", "  int i = 0;", "  static set n(int x) {i = 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'; }", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.INVALID_GETTER_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
@@ skipping 86 matching lines @@
     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();", "}"]));
+    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();", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR]);
   }
   void test_newWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A.name() {}", "}", "f() {", "  new A();", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
     verify([source]);
   }
-  void test_noDefaultSuperConstructorExplicit() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A(p);", "}", "class B extends A {", "  B() {}", "}"]));
-    resolve(source);
-    assertErrors([StaticWarningCode.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([StaticWarningCode.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([StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
-    verify([source]);
-  }
   void test_nonAbstractClassInheritsAbstractMemberFivePlus() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "  o();", "  p();", "  q();", "}", "class C extends A {", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS]);
     verify([source]);
   }
   void test_nonAbstractClassInheritsAbstractMemberFour() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "  n();", "  o();", "  p();", "}", "class C extends A {", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR]);
@@ skipping 123 matching lines @@
   void test_redirectToMissingConstructor_named() {
     Source source = addSource(EngineTestCase.createSource(["class A implements B{", "  A() {}", "}", "class B {", "  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;", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
   }
-  void test_redirectToNonClass() {
+  void test_redirectToNonClass_notAType() {
+    Source source = addSource(EngineTestCase.createSource(["class B {", "  int A;", "  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;", "}"]));
     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]);
@@ skipping 48 matching lines @@
   void test_undefinedClass_variableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["f() { C c; }"]));
     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;", "}"]));
+    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]);
   }
   void test_undefinedIdentifier_metadata() {
     Source source = addSource(EngineTestCase.createSource(["@undefined class A {}"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
@@ skipping 10 matching lines @@
   static dartSuite() {
     _ut.group('StaticWarningCodeTest', () {
       _ut.test('test_ambiguousImport_typeAnnotation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_typeAnnotation);
       });
       _ut.test('test_ambiguousImport_typeArgument_annotation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_typeArgument_annotation);
       });
+      _ut.test('test_argumentTypeNotAssignable_annotation_namedConstructor', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_annotation_namedConstructor);
+      });
+      _ut.test('test_argumentTypeNotAssignable_annotation_unnamedConstructor', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_annotation_unnamedConstructor);
+      });
       _ut.test('test_argumentTypeNotAssignable_binary', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_binary);
       });
       _ut.test('test_argumentTypeNotAssignable_index', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_index);
       });
       _ut.test('test_argumentTypeNotAssignable_invocation_callParameter', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 292 matching lines @@
         runJUnitTest(__test, __test.test_mismatchedAccessorTypes_topLevel);
       });
       _ut.test('test_newWithAbstractClass', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithAbstractClass);
       });
       _ut.test('test_newWithNonType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithNonType);
       });
+      _ut.test('test_newWithNonType_fromLibrary', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_newWithNonType_fromLibrary);
+      });
       _ut.test('test_newWithUndefinedConstructor', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithUndefinedConstructor);
       });
       _ut.test('test_newWithUndefinedConstructorDefault', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithUndefinedConstructorDefault);
       });
-      _ut.test('test_noDefaultSuperConstructorExplicit', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_noDefaultSuperConstructorExplicit);
-      });
-      _ut.test('test_noDefaultSuperConstructorImplicit_superHasParameters', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superHasParameters);
-      });
-      _ut.test('test_noDefaultSuperConstructorImplicit_superOnlyNamed', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_noDefaultSuperConstructorImplicit_superOnlyNamed);
-      });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberFivePlus', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberFivePlus);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberFour', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberFour);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 76 matching lines @@
         runJUnitTest(__test, __test.test_redirectToInvalidReturnType);
       });
       _ut.test('test_redirectToMissingConstructor_named', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_redirectToMissingConstructor_named);
       });
       _ut.test('test_redirectToMissingConstructor_unnamed', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_redirectToMissingConstructor_unnamed);
       });
-      _ut.test('test_redirectToNonClass', () {
+      _ut.test('test_redirectToNonClass_notAType', () {
         final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_redirectToNonClass);
+        runJUnitTest(__test, __test.test_redirectToNonClass_notAType);
+      });
+      _ut.test('test_redirectToNonClass_undefinedIdentifier', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_redirectToNonClass_undefinedIdentifier);
       });
       _ut.test('test_returnWithoutValue', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_returnWithoutValue);
       });
       _ut.test('test_staticAccessToInstanceMember_method_invocation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_method_invocation);
       });
       _ut.test('test_staticAccessToInstanceMember_method_reference', () {
@@ skipping 25 matching lines @@
         runJUnitTest(__test, __test.test_undefinedClassBoolean_variableDeclaration);
       });
       _ut.test('test_undefinedClass_instanceCreation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedClass_instanceCreation);
       });
       _ut.test('test_undefinedClass_variableDeclaration', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedClass_variableDeclaration);
       });
+      _ut.test('test_undefinedGetter_fromLibrary', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_undefinedGetter_fromLibrary);
+      });
       _ut.test('test_undefinedIdentifier_initializer', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_initializer);
       });
       _ut.test('test_undefinedIdentifier_metadata', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_metadata);
       });
       _ut.test('test_undefinedIdentifier_methodInvocation', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 102 matching lines @@
    * The type representing the built-in type 'StackTrace'.
    */
   InterfaceType _stackTraceType;
 
   /**
    * The type representing the built-in type 'String'.
    */
   InterfaceType _stringType;
 
   /**
+   * The type representing the built-in type 'Symbol'.
+   */
+  InterfaceType _symbolType;
+
+  /**
    * The type representing the built-in type 'Type'.
    */
   InterfaceType _typeType;
   InterfaceType get boolType {
     if (_boolType == null) {
       _boolType = ElementFactory.classElement2("bool", []).type;
     }
     return _boolType;
   }
   Type2 get bottomType {
@@ skipping 95 matching lines @@
   }
   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.substitute5(<Type2> [intType]))];
       stringElement.methods = <MethodElement> [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.
@@ skipping 16 matching lines @@
     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, [])];
   }
 
   /**
    * 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);
     for (PropertyAccessorElement accessor in classElement.accessors) {
       FunctionTypeImpl functionType = accessor.type as FunctionTypeImpl;
       functionType.typeArguments = typeArguments;
     }
     for (MethodElement method in classElement.methods) {
       FunctionTypeImpl functionType = method.type as FunctionTypeImpl;
       functionType.typeArguments = typeArguments;
     }
     for (ConstructorElement constructor in classElement.constructors) {
       FunctionTypeImpl functionType = constructor.type as FunctionTypeImpl;
       functionType.typeArguments = typeArguments;
     }
   }
 }
 /**
  * The class `AnalysisContextFactory` defines utility methods used to create analysis contexts
  * for testing purposes.
  */
 class AnalysisContextFactory {
 
   /**
    * Create an analysis context that has a fake core library already resolved.
+   *
    * @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;
@@ skipping 183 matching lines @@
   }
   _jtd_constructor_361_impl() {
     _jtd_constructor_362_impl(null);
   }
 
   /**
    * Initialize a newly created verifier to verify that all of the identifiers in the visited AST
    * structures that are expected to have been resolved have an element associated with them. Nodes
    * in the set of known exceptions are not expected to have been resolved, even if they normally
    * would have been expected to have been resolved.
+   *
    * @param knownExceptions a set containing nodes that are known to not be resolvable and should
-   * therefore not cause the test to fail
-   */
+   *          therefore not cause the test to fail
+   **/
   ResolutionVerifier.con1(Set<ASTNode> knownExceptions2) {
     _jtd_constructor_362_impl(knownExceptions2);
   }
   _jtd_constructor_362_impl(Set<ASTNode> knownExceptions2) {
     this._knownExceptions = knownExceptions2;
   }
 
   /**
    * Assert that all of the visited identifiers were resolved.
    */
@@ skipping 725 matching lines @@
   }
   void test_visitThrowExpression_withValue() {
     Expression node = ASTFactory.throwExpression2(resolvedInteger(0));
     JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node));
     _listener.assertNoErrors();
   }
 
   /**
    * Return the type associated with the given expression after the static type analyzer has
    * computed a type for it.
+   *
    * @param node the expression with which the type is associated
    * @return the type associated with the expression
    */
   Type2 analyze(Expression node) => analyze2(node, null);
 
   /**
    * Return the type associated with the given expression after the static type analyzer has
    * computed a type for it.
+   *
    * @param node the expression with which the type is associated
    * @param thisType the type of 'this'
    * @return the type associated with the expression
    */
   Type2 analyze2(Expression node, InterfaceType thisType) {
     try {
       _analyzer.thisType_J2DAccessor = thisType;
     } catch (exception) {
       throw new IllegalArgumentException("Could not set type of 'this'", exception);
     }
     node.accept(_analyzer);
     return node.staticType;
   }
 
   /**
    * Return the type associated with the given parameter after the static type analyzer has computed
    * a type for it.
+   *
    * @param node the parameter with which the type is associated
    * @return the type associated with the parameter
    */
   Type2 analyze3(FormalParameter node) {
     node.accept(_analyzer);
     return ((node.identifier.element as ParameterElement)).type;
   }
 
   /**
    * Assert that the actual type is a function type with the expected characteristics.
+   *
    * @param expectedReturnType the expected return type of the function
    * @param expectedNormalTypes the expected types of the normal parameters
    * @param expectedOptionalTypes the expected types of the optional parameters
    * @param expectedNamedTypes the expected types of the named parameters
    * @param actualType the type being tested
    */
   void assertFunctionType(Type2 expectedReturnType, List<Type2> expectedNormalTypes, List<Type2> expectedOptionalTypes, Map<String, Type2> expectedNamedTypes, Type2 actualType) {
     EngineTestCase.assertInstanceOf(FunctionType, actualType);
     FunctionType functionType = actualType as FunctionType;
     List<Type2> normalTypes = functionType.normalParameterTypes;
@@ skipping 40 matching lines @@
   }
   void assertType2(Type2 expectedType, Type2 actualType) {
     if (expectedType is InterfaceTypeImpl) {
       EngineTestCase.assertInstanceOf(InterfaceTypeImpl, actualType);
       assertType((expectedType as InterfaceTypeImpl), (actualType as InterfaceTypeImpl));
     }
   }
 
   /**
    * Create the analyzer used by the tests.
+   *
    * @return the analyzer to be used by the tests
    */
   StaticTypeAnalyzer createAnalyzer() {
     AnalysisContextImpl context = new AnalysisContextImpl();
     SourceFactory sourceFactory = new SourceFactory.con2([new DartUriResolver(DirectoryBasedDartSdk.defaultSdk)]);
     context.sourceFactory = sourceFactory;
     FileBasedSource source = new FileBasedSource.con1(sourceFactory.contentCache, FileUtilities2.createFile("/lib.dart"));
     CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary = new LibraryElementImpl(context, null);
     definingLibrary.definingCompilationUnit = definingCompilationUnit;
     Library library = new Library(context, _listener, source);
     library.libraryElement = definingLibrary;
     _visitor = new ResolverVisitor.con1(library, source, _typeProvider);
     _visitor.overrideManager.enterScope();
     try {
       return _visitor.typeAnalyzer_J2DAccessor as StaticTypeAnalyzer;
     } catch (exception) {
       throw new IllegalArgumentException("Could not create analyzer", exception);
     }
   }
 
   /**
    * Return an integer literal that has been resolved to the correct type.
+   *
    * @param value the value of the literal
    * @return an integer literal that has been resolved to the correct type
    */
   DoubleLiteral resolvedDouble(double value) {
     DoubleLiteral literal = ASTFactory.doubleLiteral(value);
     literal.staticType = _typeProvider.doubleType;
     return literal;
   }
 
   /**
    * Create a function expression that has an element associated with it, where the element has an
-   * incomplete type associated with it (just like the one[ElementBuilder#visitFunctionExpression] would have built if we had
+   * incomplete type associated with it (just like the one
+   * [ElementBuilder#visitFunctionExpression] would have built if we had
    * run it).
+   *
    * @param parameters the parameters to the function
    * @param body the body of the function
    * @return a resolved function expression
    */
   FunctionExpression resolvedFunctionExpression(FormalParameterList parameters2, FunctionBody body) {
     for (FormalParameter parameter in parameters2.parameters) {
       ParameterElementImpl element = new ParameterElementImpl(parameter.identifier);
       element.parameterKind = parameter.kind;
       element.type = _typeProvider.dynamicType;
       parameter.identifier.element = element;
     }
     FunctionExpression node = ASTFactory.functionExpression2(parameters2, body);
     FunctionElementImpl element = new FunctionElementImpl.con1(null);
     element.type = new FunctionTypeImpl.con1(element);
     node.element = element;
     return node;
   }
 
   /**
    * Return an integer literal that has been resolved to the correct type.
+   *
    * @param value the value of the literal
    * @return an integer literal that has been resolved to the correct type
    */
   IntegerLiteral resolvedInteger(int value) {
     IntegerLiteral literal = ASTFactory.integer(value);
     literal.staticType = _typeProvider.intType;
     return literal;
   }
 
   /**
    * Return a string literal that has been resolved to the correct type.
+   *
    * @param value the value of the literal
    * @return a string literal that has been resolved to the correct type
    */
   SimpleStringLiteral resolvedString(String value) {
     SimpleStringLiteral string = ASTFactory.string2(value);
     string.staticType = _typeProvider.stringType;
     return string;
   }
 
   /**
    * Return a simple identifier that has been resolved to a variable element with the given type.
+   *
    * @param type the type of the variable being represented
    * @param variableName the name of the variable
    * @return a simple identifier that has been resolved to a variable element with the given type
    */
   SimpleIdentifier resolvedVariable(InterfaceType type2, String variableName) {
     SimpleIdentifier identifier = ASTFactory.identifier3(variableName);
     VariableElementImpl element = ElementFactory.localVariableElement(identifier);
     element.type = type2;
     identifier.element = element;
     identifier.staticType = type2;
     return identifier;
   }
 
   /**
    * Sets the element for the node and remembers it as the static resolution.
    */
   void setStaticElement(BinaryExpression node, MethodElement element2) {
     node.staticElement = element2;
     node.element = element2;
   }
 
   /**
    * Set the type of the given parameter to the given type.
+   *
    * @param parameter the parameter whose type is to be set
    * @param type the new type of the given parameter
    */
   void setType(FormalParameter parameter, Type2 type2) {
     SimpleIdentifier identifier = parameter.identifier;
     Element element = identifier.element;
     if (element is! ParameterElement) {
       element = new ParameterElementImpl(identifier);
       identifier.element = element;
     }
@@ skipping 265 matching lines @@
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitThrowExpression_withoutValue);
       });
     });
   }
 }
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     LibraryElement definingLibrary2 = createTestLibrary();
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
-    Scope rootScope = new Scope_16(definingLibrary2, errorListener2);
+    Scope rootScope = new Scope_17(definingLibrary2, errorListener2);
     EnclosedScope scope = new EnclosedScope(rootScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
     errorListener2.assertErrors3([ErrorSeverity.ERROR]);
   }
   void test_define_normal() {
     LibraryElement definingLibrary3 = createTestLibrary();
     GatheringErrorListener errorListener3 = new GatheringErrorListener();
-    Scope rootScope = new Scope_17(definingLibrary3, errorListener3);
+    Scope rootScope = new Scope_18(definingLibrary3, errorListener3);
     EnclosedScope outerScope = new EnclosedScope(rootScope);
     EnclosedScope innerScope = new EnclosedScope(outerScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v2"));
     outerScope.define(element1);
     innerScope.define(element2);
     errorListener3.assertNoErrors();
   }
   static dartSuite() {
     _ut.group('EnclosedScopeTest', () {
       _ut.test('test_define_duplicate', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_duplicate);
       });
       _ut.test('test_define_normal', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_normal);
       });
     });
   }
 }
-class Scope_16 extends Scope {
+class Scope_17 extends Scope {
   LibraryElement definingLibrary2;
   GatheringErrorListener errorListener2;
-  Scope_16(this.definingLibrary2, this.errorListener2) : super();
+  Scope_17(this.definingLibrary2, this.errorListener2) : super();
   LibraryElement get definingLibrary => definingLibrary2;
   AnalysisErrorListener get errorListener => errorListener2;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
-class Scope_17 extends Scope {
+class Scope_18 extends Scope {
   LibraryElement definingLibrary3;
   GatheringErrorListener errorListener3;
-  Scope_17(this.definingLibrary3, this.errorListener3) : super();
+  Scope_18(this.definingLibrary3, this.errorListener3) : super();
   LibraryElement get definingLibrary => definingLibrary3;
   AnalysisErrorListener get errorListener => errorListener3;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 class LibraryElementBuilderTest extends EngineTestCase {
 
   /**
-   * The source factory used to create [Source sources].
+   * 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';"]));
     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, []);
@@ skipping 63 matching lines @@
   }
   void test_singleFile() {
     Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "", "class A {}"]));
     LibraryElement element = buildLibrary(librarySource, []);
     JUnitTestCase.assertNotNull(element);
     assertTypes(element.definingCompilationUnit, ["A"]);
   }
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
+   *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource(String filePath, String contents) {
     Source source = new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(filePath));
     _sourceFactory.setContents(source, contents);
     return source;
   }
 
   /**
    * Ensure that there are elements representing all of the types in the given array of type names.
+   *
    * @param unit the compilation unit containing the types
    * @param typeNames the names of the types that should be found
    */
   void assertTypes(CompilationUnitElement unit, List<String> typeNames) {
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> types = unit.types;
     EngineTestCase.assertLength(typeNames.length, types);
     for (ClassElement type in types) {
       JUnitTestCase.assertNotNull(type);
       String actualTypeName = type.displayName;
       bool wasExpected = false;
       for (String expectedTypeName in typeNames) {
         if (expectedTypeName == actualTypeName) {
           wasExpected = true;
         }
       }
       if (!wasExpected) {
         JUnitTestCase.fail("Found unexpected type ${actualTypeName}");
       }
     }
   }
 
   /**
    * 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
+   *          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()]);
     LibraryResolver resolver = new LibraryResolver(context);
     LibraryElementBuilder builder = new LibraryElementBuilder(resolver);
     Library library = resolver.createLibrary(librarySource) as Library;
     LibraryElement element = builder.buildLibrary(library);
@@ skipping 447 matching lines @@
    * to be a class, the first member of which is expected to be a method with a block body, and the
    * first statement in the body is expected to be an expression statement whose expression is a
    * method invocation. It is the arguments to that method invocation that are tested. The method
    * invocation can contain errors.
    *
    * The arguments were resolved correctly if the number of expressions in the list matches the
    * length of the array of indices and if, for each index in the array of indices, the parameter to
    * which the argument expression was resolved is the parameter in the invoked method's list of
    * parameters at that index. Arguments that should not be resolved to a parameter because of an
    * error can be denoted by including a negative index in the array of indices.
+   *
    * @param source the source to be resolved
    * @param indices the array of indices used to associate arguments with parameters
    * @throws Exception if the source could not be resolved or if the structure of the source is not
-   * valid
+   *           valid
    */
   void validateArgumentResolution(Source source, List<int> indices) {
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     ClassElement classElement = library.definingCompilationUnit.types[0];
     List<ParameterElement> parameters = classElement.methods[1].parameters;
     CompilationUnit unit = resolveCompilationUnit(source, library);
     JUnitTestCase.assertNotNull(unit);
     ClassDeclaration classDeclaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration methodDeclaration = (classDeclaration.members[0] as MethodDeclaration);
@@ skipping 210 matching lines @@
 //  ScopeTest.dartSuite();
 //  CompileTimeErrorCodeTest.dartSuite();
 //  ErrorResolverTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }