New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/resolver_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver_test;
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart' show ParserErrorCode;
@@ skipping 929 matching lines @@
         "    call() => 0;",
         "  }",
         "",
         "  main() {",
         "    caller(new CallMeBack());",
         "  }"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_argumentTypeNotAssignable_fieldFormalParameterElement_member() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class ObjectSink<T> {",
+        "  void sink(T object) {",
+        "    new TimestampedObject<T>(object);",
+        "  }",
+        "}",
+        "class TimestampedObject<E> {",
+        "  E object2;",
+        "  TimestampedObject(this.object2);",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_argumentTypeNotAssignable_invocation_functionParameter_generic() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<K> {",
         "  m(f(K k), K v) {",
         "    f(v);",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 422 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_dynamicIdentifier() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  var v = dynamic;", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_expectedOneListTypeArgument() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  <int> [];", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_expectedTwoMapTypeArguments() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  <int, int> {};", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_exportOfNonLibrary_libraryDeclared() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_exportOfNonLibrary_libraryNotDeclared() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource([""]));
@@ skipping 633 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideRequired_less() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m(a, b) {}",
         "}",
         "class B extends A {",
-        "  m(a) {}",
+        "  m(a, [b]) {}",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_invalidOverrideRequired_same() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m(a) {}",
         "}",
@@ skipping 287 matching lines @@
   void test_mixinDeclaresConstructor_factory() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  factory A() {}",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
-  void test_mixinInheritsFromNotObject_classDeclaration_mixTypedef() {
+  void test_mixinInheritsFromNotObject_classDeclaration_mixTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
-        "typedef B = Object with A;",
+        "class B = Object with A;",
         "class C extends Object with B {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
-  void test_mixinInheritsFromNotObject_typedef_mixTypedef() {
+  void test_mixinInheritsFromNotObject_typedef_mixTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
-        "typedef B = Object with A;",
-        "typedef C = Object with B;"]));
+        "class B = Object with A;",
+        "class C = Object with B;"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_multipleSuperInitializers_no() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {", "  B() {}", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 417 matching lines @@
         "import 'lib.dart' as p;",
         "typedef P();",
         "p2() {}",
         "var p3;",
         "class p4 {}",
         "p.A a;"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_propagateTypeArgsIntoBounds() {
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A<E> {}",
+        "abstract class B<F> implements A<F>{}",
+        "abstract class C<G, H extends A<G>> {}",
+        "class D<I> extends C<I, B<I>> {}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_proxy_annotation_prefixed() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'meta.dart';",
         "@proxy",
         "class A {}",
         "f(A a) {",
         "  a.m();",
         "  var x = a.g;",
         "  a.s = 1;",
@@ skipping 105 matching lines @@
         "class A implements B {",
         "  A(int p) {}",
         "}",
         "class B {",
         "  factory B(int p) = A;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_redirectToInvalidReturnType() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "}",
+        "class B extends A {",
+        "  factory B() = A;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_redirectToNonConstConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.a();",
         "  const factory A.b() = A.a;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 285 matching lines @@
         "class A {",
         "  A() {}",
         "}",
         "class B extends A {",
         "  B();",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
-  void test_undefinedConstructorInInitializer_implicit_typedef() {
+  void test_undefinedConstructorInInitializer_implicit_typeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "class M {}",
-        "typedef A = Object with M;",
+        "class A = Object with M;",
         "class B extends A {",
         "  B();",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_undefinedConstructorInInitializer_redirecting() {
     Source source = addSource(EngineTestCase.createSource([
         "class Foo {",
@@ skipping 170 matching lines @@
         runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_optionalParameter);
       });
       _ut.test('test_argumentTypeNotAssignable_Object_Function', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_Object_Function);
       });
       _ut.test('test_argumentTypeNotAssignable_classWithCall_Function', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_classWithCall_Function);
       });
+      _ut.test('test_argumentTypeNotAssignable_fieldFormalParameterElement_member', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_fieldFormalParameterElement_member);
+      });
       _ut.test('test_argumentTypeNotAssignable_invocation_functionParameter_generic', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_functionParameter_generic);
       });
       _ut.test('test_argumentTypeNotAssignable_invocation_typedef_generic', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_typedef_generic);
       });
       _ut.test('test_argumentTypeNotAssignable_typedef_local', () {
         final __test = new NonErrorResolverTest();
@@ skipping 140 matching lines @@
         runJUnitTest(__test, __test.test_duplicateDefinition_emptyName);
       });
       _ut.test('test_duplicateDefinition_getter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_duplicateDefinition_getter);
       });
       _ut.test('test_dynamicIdentifier', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_dynamicIdentifier);
       });
+      _ut.test('test_expectedOneListTypeArgument', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_expectedOneListTypeArgument);
+      });
+      _ut.test('test_expectedTwoMapTypeArguments', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_expectedTwoMapTypeArguments);
+      });
       _ut.test('test_exportOfNonLibrary_libraryDeclared', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_exportOfNonLibrary_libraryDeclared);
       });
       _ut.test('test_exportOfNonLibrary_libraryNotDeclared', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_exportOfNonLibrary_libraryNotDeclared);
       });
       _ut.test('test_extraPositionalArguments_Function', () {
         final __test = new NonErrorResolverTest();
@@ skipping 380 matching lines @@
         runJUnitTest(__test, __test.test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedSetter);
       });
       _ut.test('test_mixinDeclaresConstructor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_mixinDeclaresConstructor);
       });
       _ut.test('test_mixinDeclaresConstructor_factory', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_mixinDeclaresConstructor_factory);
       });
-      _ut.test('test_mixinInheritsFromNotObject_classDeclaration_mixTypedef', () {
+      _ut.test('test_mixinInheritsFromNotObject_classDeclaration_mixTypeAlias', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_classDeclaration_mixTypedef);
+        runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_classDeclaration_mixTypeAlias);
       });
-      _ut.test('test_mixinInheritsFromNotObject_typedef_mixTypedef', () {
+      _ut.test('test_mixinInheritsFromNotObject_typedef_mixTypeAlias', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_typedef_mixTypedef);
+        runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_typedef_mixTypeAlias);
       });
       _ut.test('test_multipleSuperInitializers_no', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_multipleSuperInitializers_no);
       });
       _ut.test('test_multipleSuperInitializers_single', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_multipleSuperInitializers_single);
       });
       _ut.test('test_newWithAbstractClass_factory', () {
@@ skipping 153 matching lines @@
         runJUnitTest(__test, __test.test_null_callOperator);
       });
       _ut.test('test_optionalParameterInOperator_required', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_optionalParameterInOperator_required);
       });
       _ut.test('test_prefixCollidesWithTopLevelMembers', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_prefixCollidesWithTopLevelMembers);
       });
+      _ut.test('test_propagateTypeArgsIntoBounds', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_propagateTypeArgsIntoBounds);
+      });
       _ut.test('test_proxy_annotation_prefixed', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_proxy_annotation_prefixed);
       });
       _ut.test('test_proxy_annotation_prefixed2', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_proxy_annotation_prefixed2);
       });
       _ut.test('test_proxy_annotation_prefixed3', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_proxy_annotation_prefixed3);
       });
       _ut.test('test_proxy_annotation_simple', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_proxy_annotation_simple);
       });
       _ut.test('test_recursiveConstructorRedirect', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_recursiveConstructorRedirect);
       });
       _ut.test('test_recursiveFactoryRedirect', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_recursiveFactoryRedirect);
       });
       _ut.test('test_redirectToInvalidFunctionType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_redirectToInvalidFunctionType);
       });
+      _ut.test('test_redirectToInvalidReturnType', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_redirectToInvalidReturnType);
+      });
       _ut.test('test_redirectToNonConstConstructor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_redirectToNonConstConstructor);
       });
       _ut.test('test_referenceToDeclaredVariableInInitializer_constructorName', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_constructorName);
       });
       _ut.test('test_referenceToDeclaredVariableInInitializer_methodName', () {
         final __test = new NonErrorResolverTest();
@@ skipping 96 matching lines @@
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_unnamed);
       });
       _ut.test('test_undefinedConstructorInInitializer_hasOptionalParameters', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_hasOptionalParameters);
       });
       _ut.test('test_undefinedConstructorInInitializer_implicit', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_implicit);
       });
-      _ut.test('test_undefinedConstructorInInitializer_implicit_typedef', () {
+      _ut.test('test_undefinedConstructorInInitializer_implicit_typeAlias', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_implicit_typedef);
+        runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_implicit_typeAlias);
       });
       _ut.test('test_undefinedConstructorInInitializer_redirecting', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_redirecting);
       });
       _ut.test('test_undefinedGetter_typeSubstitution', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedGetter_typeSubstitution);
       });
       _ut.test('test_undefinedIdentifier_hide', () {
@@ skipping 179 matching lines @@
     });
   }
 }
 class StaticTypeWarningCodeTest extends ResolverTestCase {
   void fail_inaccessibleSetter() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.INACCESSIBLE_SETTER]);
     verify([source]);
   }
+  void test_expectedOneListTypeArgument() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  <int, int> [];", "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS]);
+    verify([source]);
+  }
+  void test_expectedTwoMapTypeArguments_one() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  <int> {};", "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
+    verify([source]);
+  }
+  void test_expectedTwoMapTypeArguments_three() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  <int, int, int> {};", "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
+    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 {",
         "}"]));
@@ skipping 334 matching lines @@
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_classTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class C {}",
         "class G<E extends A> {}",
-        "typedef D = G<B> with C;"]));
+        "class D = G<B> with C;"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_extends() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "class C extends G<B>{}"]));
@@ skipping 154 matching lines @@
   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(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
+  void test_typeParameterSupertypeOfItsBound() {
+    Source source = addSource(EngineTestCase.createSource(["class A<T extends T> {", "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND]);
+    verify([source]);
+  }
   void test_undefinedGetter() {
     Source source = addSource(EngineTestCase.createSource(["class T {}", "f(T e) { return e.m; }"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
   void test_undefinedGetter_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "var a = A.B;"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
@@ skipping 22 matching lines @@
         "}",
         "class C {",
         "  f() {",
         "    A a = new B();",
         "    a.m();",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
+  void test_undefinedMethod_private() {
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {", "  _foo() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib.dart';",
+        "class B extends A {",
+        "  test() {",
+        "    _foo();",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+  }
   void test_undefinedOperator_indexBoth() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0]++;", "}"]));
     resolve(source);
     assertErrors(source, [
         StaticTypeWarningCode.UNDEFINED_OPERATOR,
         StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_indexGetter() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0];", "}"]));
     resolve(source);
@@ skipping 109 matching lines @@
         "class C<E> {}",
         "f(p) {",
         "  return p is C<A, A>;",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
     verify([source]);
   }
   static dartSuite() {
     _ut.group('StaticTypeWarningCodeTest', () {
+      _ut.test('test_expectedOneListTypeArgument', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_expectedOneListTypeArgument);
+      });
+      _ut.test('test_expectedTwoMapTypeArguments_one', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_expectedTwoMapTypeArguments_one);
+      });
+      _ut.test('test_expectedTwoMapTypeArguments_three', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_expectedTwoMapTypeArguments_three);
+      });
       _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);
       });
       _ut.test('test_inconsistentMethodInheritance_returnType', () {
         final __test = new StaticTypeWarningCodeTest();
@@ skipping 208 matching lines @@
         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_typeParameterSupertypeOfItsBound', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typeParameterSupertypeOfItsBound);
+      });
       _ut.test('test_undefinedGetter', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedGetter);
       });
       _ut.test('test_undefinedGetter_static', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedGetter_static);
       });
       _ut.test('test_undefinedMethod', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedMethod);
       });
       _ut.test('test_undefinedMethod_assignmentExpression', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedMethod_assignmentExpression);
       });
       _ut.test('test_undefinedMethod_ignoreTypePropagation', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedMethod_ignoreTypePropagation);
       });
+      _ut.test('test_undefinedMethod_private', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_undefinedMethod_private);
+      });
       _ut.test('test_undefinedOperator_indexBoth', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedOperator_indexBoth);
       });
       _ut.test('test_undefinedOperator_indexGetter', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedOperator_indexGetter);
       });
       _ut.test('test_undefinedOperator_indexSetter', () {
         final __test = new StaticTypeWarningCodeTest();
@@ skipping 445 matching lines @@
         "class B {",
         "  f(var a, var a2) {",
         "    a = new A();",
         "    a2 = new A();",
         "    a += a2;",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_METHOD]);
   }
+  void test_undefinedOperator_binaryExpression() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    a + 1;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
+  }
   void test_undefinedOperator_indexBoth() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "f(var a) {",
         "  if(a is A) {",
         "    a[0]++;",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR, HintCode.UNDEFINED_OPERATOR]);
@@ skipping 11 matching lines @@
   }
   void test_undefinedOperator_indexSetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "f(var a) {",
         "  if(a is A) {",
         "    a[0] = 1;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
-  }
-  void test_undefinedOperator_plus() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a + 1;",
-        "  }",
-        "}"]));
-    resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_postfixExpression() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "f(var a) {",
         "  if(a is A) {",
         "    a++;",
         "  }",
         "}"]));
@@ skipping 288 matching lines @@
         runJUnitTest(__test, __test.test_undefinedGetter_message);
       });
       _ut.test('test_undefinedMethod', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_undefinedMethod);
       });
       _ut.test('test_undefinedMethod_assignmentExpression', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_undefinedMethod_assignmentExpression);
       });
+      _ut.test('test_undefinedOperator_binaryExpression', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedOperator_binaryExpression);
+      });
       _ut.test('test_undefinedOperator_indexBoth', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_undefinedOperator_indexBoth);
       });
       _ut.test('test_undefinedOperator_indexGetter', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_undefinedOperator_indexGetter);
       });
       _ut.test('test_undefinedOperator_indexSetter', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_undefinedOperator_indexSetter);
       });
-      _ut.test('test_undefinedOperator_plus', () {
-        final __test = new HintCodeTest();
-        runJUnitTest(__test, __test.test_undefinedOperator_plus);
-      });
       _ut.test('test_undefinedOperator_postfixExpression', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_undefinedOperator_postfixExpression);
       });
       _ut.test('test_undefinedOperator_prefixExpression', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_undefinedOperator_prefixExpression);
       });
       _ut.test('test_undefinedSetter', () {
         final __test = new HintCodeTest();
@@ skipping 1431 matching lines @@
         CompileTimeErrorCode.UNDEFINED_FUNCTION]);
   }
   void test_argumentDefinitionTestNonParameter() {
     Source source = addSource(EngineTestCase.createSource(["f() {", " var v = 0;", " return ?v;", "}"]));
     resolve(source);
     assertErrors(source, [
         ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST,
         CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER]);
     verify([source]);
   }
+  void test_builtInIdentifierAsMixinName_classTypeAlias() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class as = A with B;"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
+    verify([source]);
+  }
   void test_builtInIdentifierAsType_formalParameter_field() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  var x;", "  A(static this.x);", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
     verify([source]);
   }
   void test_builtInIdentifierAsType_formalParameter_simple() {
     Source source = addSource(EngineTestCase.createSource(["f(static x) {", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
     verify([source]);
   }
   void test_builtInIdentifierAsType_variableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  typedef x;", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
     verify([source]);
   }
-  void test_builtInIdentifierAsTypedefName_classTypeAlias() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "typedef as = A with B;"]));
-    resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
-    verify([source]);
-  }
   void test_builtInIdentifierAsTypedefName_functionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef bool as();"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypeName() {
     Source source = addSource(EngineTestCase.createSource(["class as {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME]);
@@ skipping 79 matching lines @@
         "class A {",
         "  m() {}",
         "}",
         "class B extends A {",
         "  get m => 0;",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
     verify([source]);
   }
+  void test_conflictingTypeVariableAndClass() {
+    Source source = addSource(EngineTestCase.createSource(["class T<T> {", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS]);
+    verify([source]);
+  }
+  void test_conflictingTypeVariableAndMember_field() {
+    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  var T;", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
+    verify([source]);
+  }
+  void test_conflictingTypeVariableAndMember_getter() {
+    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  get T => null;", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
+    verify([source]);
+  }
+  void test_conflictingTypeVariableAndMember_method() {
+    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  T() {}", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
+    verify([source]);
+  }
+  void test_conflictingTypeVariableAndMember_method_static() {
+    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  static T() {}", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
+    verify([source]);
+  }
+  void test_conflictingTypeVariableAndMember_setter() {
+    Source source = addSource(EngineTestCase.createSource(["class A<T> {", "  set T(x) {}", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
+    verify([source]);
+  }
   void test_constConstructorWithNonConstSuper_explicit() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A();",
         "}",
         "class B extends A {",
         "  const B(): super();",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER]);
@@ skipping 183 matching lines @@
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
   void test_constInstanceField() {
     Source source = addSource(EngineTestCase.createSource(["class C {", "  const int f = 0;", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_INSTANCE_FIELD]);
     verify([source]);
   }
+  void test_constMapKeyTypeImplementsEquals_direct() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "  operator ==(other) => false;",
+        "}",
+        "main() {",
+        "  const {const A() : 0};",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
+  void test_constMapKeyTypeImplementsEquals_super() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  const A();",
+        "  operator ==(other) => false;",
+        "}",
+        "class B extends A {",
+        "  const B();",
+        "}",
+        "main() {",
+        "  const {const B() : 0};",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
   void test_constWithInvalidTypeParameters() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "f() { return const A<A>(); }"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
@@ skipping 598 matching lines @@
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DYNAMIC]);
     verify([source]);
   }
   void test_implementsNonClass_class() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B implements A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
     verify([source]);
   }
-  void test_implementsNonClass_typedef() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "int B;", "typedef C = A implements B;"]));
+  void test_implementsNonClass_typeAlias() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "int B;", "class C = A implements B;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
     verify([source]);
   }
   void test_implementsRepeated() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B implements A, A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_REPEATED]);
     verify([source]);
   }
@@ skipping 462 matching lines @@
   void test_mixinDeclaresConstructor_classDeclaration() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
-  void test_mixinDeclaresConstructor_typedef() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  A() {}",
-        "}",
-        "typedef B = Object with A;"]));
+  void test_mixinDeclaresConstructor_typeAlias() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "class B = Object with A;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_classDeclaration_extends() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "class C extends Object with B {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
   void test_mixinInheritsFromNotObject_classDeclaration_with() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends Object with A {}",
         "class C extends Object with B {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
-  void test_mixinInheritsFromNotObject_typedef_extends() {
+  void test_mixinInheritsFromNotObject_typeAlias_extends() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
-        "typedef C = Object with B;"]));
+        "class C = Object with B;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
-  void test_mixinInheritsFromNotObject_typedef_with() {
+  void test_mixinInheritsFromNotObject_typeAlias_with() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends Object with A {}",
-        "typedef C = Object with B;"]));
+        "class C = Object with B;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
     verify([source]);
   }
   void test_mixinOfDisallowedClass_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A extends Object with bool {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
@@ skipping 26 matching lines @@
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_mixinOfNonClass_class() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B extends Object with A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
     verify([source]);
   }
-  void test_mixinOfNonClass_typedef() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "int B;", "typedef C = A with B;"]));
+  void test_mixinOfNonClass_typeAlias() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "int B;", "class C = A with B;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
     verify([source]);
   }
   void test_mixinReferencesSuper() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  toString() => super.toString();",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]);
     verify([source]);
   }
   void test_mixinWithNonClassSuperclass_class() {
     Source source = addSource(EngineTestCase.createSource(["int A;", "class B {}", "class C extends A with B {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]);
     verify([source]);
   }
-  void test_mixinWithNonClassSuperclass_typedef() {
-    Source source = addSource(EngineTestCase.createSource(["int A;", "class B {}", "typedef C = A with B;"]));
+  void test_mixinWithNonClassSuperclass_typeAlias() {
+    Source source = addSource(EngineTestCase.createSource(["int A;", "class B {}", "class C = A with B;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]);
     verify([source]);
   }
   void test_multipleRedirectingConstructorInvocations() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() : this.a(), this.b();",
         "  A.a() {}",
         "  A.b() {}",
@@ skipping 531 matching lines @@
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS]);
     verify([source]);
   }
   void test_recursiveInterfaceInheritanceBaseCaseImplements() {
     Source source = addSource(EngineTestCase.createSource(["class A implements A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
     verify([source]);
   }
-  void test_recursiveInterfaceInheritanceBaseCaseImplements_typedef() {
+  void test_recursiveInterfaceInheritanceBaseCaseImplements_typeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class M {}",
-        "typedef B = A with M implements B;"]));
+        "class B = A with M implements B;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
     verify([source]);
   }
   void test_redirectToNonConstConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.a() {}",
         "  const factory A.b() = A.a;",
         "}"]));
@@ skipping 181 matching lines @@
   }
   void test_typeAliasCannotReferenceItself_returnType_indirect() {
     Source source = addSource(EngineTestCase.createSource(["typedef B A();", "typedef A B();"]));
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotRereferenceItself_mixin_direct() {
-    Source source = addSource(EngineTestCase.createSource(["typedef M = Object with M;"]));
+    Source source = addSource(EngineTestCase.createSource(["class M = Object with M;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotRereferenceItself_mixin_indirect() {
     Source source = addSource(EngineTestCase.createSource([
-        "typedef M1 = Object with M2;",
-        "typedef M2 = Object with M1;"]));
+        "class M1 = Object with M2;",
+        "class M2 = Object with M1;"]));
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
@@ skipping 246 matching lines @@
         runJUnitTest(__test, __test.test_ambiguousExport);
       });
       _ut.test('test_ambiguousImport_function', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_function);
       });
       _ut.test('test_argumentDefinitionTestNonParameter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter);
       });
+      _ut.test('test_builtInIdentifierAsMixinName_classTypeAlias', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_builtInIdentifierAsMixinName_classTypeAlias);
+      });
       _ut.test('test_builtInIdentifierAsTypeName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypeName);
       });
       _ut.test('test_builtInIdentifierAsTypeParameterName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypeParameterName);
       });
       _ut.test('test_builtInIdentifierAsType_formalParameter_field', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsType_formalParameter_field);
       });
       _ut.test('test_builtInIdentifierAsType_formalParameter_simple', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsType_formalParameter_simple);
       });
       _ut.test('test_builtInIdentifierAsType_variableDeclaration', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsType_variableDeclaration);
       });
-      _ut.test('test_builtInIdentifierAsTypedefName_classTypeAlias', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_classTypeAlias);
-      });
       _ut.test('test_builtInIdentifierAsTypedefName_functionTypeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_functionTypeAlias);
       });
       _ut.test('test_caseExpressionTypeImplementsEquals', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals);
       });
       _ut.test('test_conflictingConstructorNameAndMember_field', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 12 matching lines @@
         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_conflictingTypeVariableAndClass', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingTypeVariableAndClass);
+      });
+      _ut.test('test_conflictingTypeVariableAndMember_field', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingTypeVariableAndMember_field);
+      });
+      _ut.test('test_conflictingTypeVariableAndMember_getter', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingTypeVariableAndMember_getter);
+      });
+      _ut.test('test_conflictingTypeVariableAndMember_method', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingTypeVariableAndMember_method);
+      });
+      _ut.test('test_conflictingTypeVariableAndMember_method_static', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingTypeVariableAndMember_method_static);
+      });
+      _ut.test('test_conflictingTypeVariableAndMember_setter', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_conflictingTypeVariableAndMember_setter);
+      });
       _ut.test('test_constConstructorWithNonConstSuper_explicit', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonConstSuper_explicit);
       });
       _ut.test('test_constConstructorWithNonConstSuper_implicit', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constConstructorWithNonConstSuper_implicit);
       });
       _ut.test('test_constConstructorWithNonFinalField_mixin', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 84 matching lines @@
         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_constMapKeyTypeImplementsEquals_direct', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constMapKeyTypeImplementsEquals_direct);
+      });
+      _ut.test('test_constMapKeyTypeImplementsEquals_super', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constMapKeyTypeImplementsEquals_super);
+      });
       _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();
@@ skipping 260 matching lines @@
         runJUnitTest(__test, __test.test_implementsDisallowedClass_num);
       });
       _ut.test('test_implementsDynamic', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsDynamic);
       });
       _ut.test('test_implementsNonClass_class', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsNonClass_class);
       });
-      _ut.test('test_implementsNonClass_typedef', () {
+      _ut.test('test_implementsNonClass_typeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_implementsNonClass_typedef);
+        runJUnitTest(__test, __test.test_implementsNonClass_typeAlias);
       });
       _ut.test('test_implementsRepeated', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsRepeated);
       });
       _ut.test('test_implementsRepeated_3times', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsRepeated_3times);
       });
       _ut.test('test_implementsSuperClass', () {
@@ skipping 225 matching lines @@
         runJUnitTest(__test, __test.test_memberWithClassName_method);
       });
       _ut.test('test_methodAndGetterWithSameName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_methodAndGetterWithSameName);
       });
       _ut.test('test_mixinDeclaresConstructor_classDeclaration', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinDeclaresConstructor_classDeclaration);
       });
-      _ut.test('test_mixinDeclaresConstructor_typedef', () {
+      _ut.test('test_mixinDeclaresConstructor_typeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_mixinDeclaresConstructor_typedef);
+        runJUnitTest(__test, __test.test_mixinDeclaresConstructor_typeAlias);
       });
       _ut.test('test_mixinInheritsFromNotObject_classDeclaration_extends', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_classDeclaration_extends);
       });
       _ut.test('test_mixinInheritsFromNotObject_classDeclaration_with', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_classDeclaration_with);
       });
-      _ut.test('test_mixinInheritsFromNotObject_typedef_extends', () {
+      _ut.test('test_mixinInheritsFromNotObject_typeAlias_extends', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_typedef_extends);
+        runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_typeAlias_extends);
       });
-      _ut.test('test_mixinInheritsFromNotObject_typedef_with', () {
+      _ut.test('test_mixinInheritsFromNotObject_typeAlias_with', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_typedef_with);
+        runJUnitTest(__test, __test.test_mixinInheritsFromNotObject_typeAlias_with);
       });
       _ut.test('test_mixinOfDisallowedClass_Null', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinOfDisallowedClass_Null);
       });
       _ut.test('test_mixinOfDisallowedClass_String', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinOfDisallowedClass_String);
       });
       _ut.test('test_mixinOfDisallowedClass_bool', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinOfDisallowedClass_bool);
       });
       _ut.test('test_mixinOfDisallowedClass_double', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinOfDisallowedClass_double);
       });
       _ut.test('test_mixinOfDisallowedClass_int', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinOfDisallowedClass_int);
       });
       _ut.test('test_mixinOfDisallowedClass_num', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinOfDisallowedClass_num);
       });
       _ut.test('test_mixinOfNonClass_class', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinOfNonClass_class);
       });
-      _ut.test('test_mixinOfNonClass_typedef', () {
+      _ut.test('test_mixinOfNonClass_typeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_mixinOfNonClass_typedef);
+        runJUnitTest(__test, __test.test_mixinOfNonClass_typeAlias);
       });
       _ut.test('test_mixinReferencesSuper', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinReferencesSuper);
       });
       _ut.test('test_mixinWithNonClassSuperclass_class', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_mixinWithNonClassSuperclass_class);
       });
-      _ut.test('test_mixinWithNonClassSuperclass_typedef', () {
+      _ut.test('test_mixinWithNonClassSuperclass_typeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_mixinWithNonClassSuperclass_typedef);
+        runJUnitTest(__test, __test.test_mixinWithNonClassSuperclass_typeAlias);
       });
       _ut.test('test_multipleRedirectingConstructorInvocations', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_multipleRedirectingConstructorInvocations);
       });
       _ut.test('test_multipleSuperInitializers', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_multipleSuperInitializers);
       });
       _ut.test('test_nativeClauseInNonSDKCode', () {
@@ skipping 197 matching lines @@
         runJUnitTest(__test, __test.test_recursiveFactoryRedirect_outsideCycle);
       });
       _ut.test('test_recursiveInterfaceInheritanceBaseCaseExtends', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_recursiveInterfaceInheritanceBaseCaseExtends);
       });
       _ut.test('test_recursiveInterfaceInheritanceBaseCaseImplements', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_recursiveInterfaceInheritanceBaseCaseImplements);
       });
-      _ut.test('test_recursiveInterfaceInheritanceBaseCaseImplements_typedef', () {
+      _ut.test('test_recursiveInterfaceInheritanceBaseCaseImplements_typeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_recursiveInterfaceInheritanceBaseCaseImplements_typedef);
+        runJUnitTest(__test, __test.test_recursiveInterfaceInheritanceBaseCaseImplements_typeAlias);
       });
       _ut.test('test_recursiveInterfaceInheritance_extends', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_recursiveInterfaceInheritance_extends);
       });
       _ut.test('test_recursiveInterfaceInheritance_extends_implements', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_recursiveInterfaceInheritance_extends_implements);
       });
       _ut.test('test_recursiveInterfaceInheritance_implements', () {
@@ skipping 1497 matching lines @@
         runJUnitTest(__test, __test.test_import_valid_inside_lib2);
       });
       _ut.test('test_import_valid_outside_lib', () {
         final __test = new PubSuggestionCodeTest();
         runJUnitTest(__test, __test.test_import_valid_outside_lib);
       });
     });
   }
 }
 class StaticWarningCodeTest extends ResolverTestCase {
-  void fail_argumentTypeNotAssignable_invocation_functionParameter_generic() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A<K, V> {",
-        "  m(f(K k), V v) {",
-        "    f(v);",
-        "  }",
-        "}"]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
-    verify([source]);
-  }
   void fail_commentReferenceConstructorNotVisible() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_CONSTRUCTOR_NOT_VISIBLE]);
     verify([source]);
   }
   void fail_commentReferenceIdentifierNotVisible() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_IDENTIFIER_NOT_VISIBLE]);
@@ skipping 316 matching lines @@
     resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_invocation_functionParameter() {
     Source source = addSource(EngineTestCase.createSource(["a(b(int p)) {", "  b('0');", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
+  void test_argumentTypeNotAssignable_invocation_functionParameter_generic() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<K, V> {",
+        "  m(f(K k), V v) {",
+        "    f(v);",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    verify([source]);
+  }
   void test_argumentTypeNotAssignable_invocation_functionTypes_optional() {
     Source source = addSource(EngineTestCase.createSource([
         "void acceptFunNumOptBool(void funNumOptBool([bool b])) {}",
         "void funNumBool(bool b) {}",
         "main() {",
         "  acceptFunNumOptBool(funNumBool);",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
@@ skipping 99 matching lines @@
     resolve(source);
     assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_CONST]);
     verify([source]);
   }
   void test_assignmentToConst_localVariable() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  const x = 0;", "  x = 1;", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_CONST]);
     verify([source]);
   }
+  void test_assignmentToFinal_excludedSetter() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var v;",
+        "}",
+        "class B extends A {",
+        "  final v = 0;",
+        "}",
+        "main() {",
+        "  new B().v = 1;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.ASSIGNMENT_TO_FINAL]);
+    verify([source]);
+  }
   void test_assignmentToFinal_instanceVariable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final v = 0;",
         "}",
         "f() {",
         "  A a = new A();",
         "  a.v = 1;",
         "}"]));
     resolve(source);
@@ skipping 82 matching lines @@
     resolve(source);
     assertErrors(source, [StaticWarningCode.CAST_TO_NON_TYPE]);
     verify([source]);
   }
   void test_concreteClassWithAbstractMember() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m();", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]);
     verify([source]);
   }
+  void test_conflictingDartImport() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib.dart';",
+        "import 'dart:async';",
+        "Future f = null;",
+        "Stream s;"]));
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class Future {}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.CONFLICTING_DART_IMPORT]);
+  }
   void test_conflictingInstanceGetterAndSuperclassMember_direct_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int v;",
         "}",
         "class B extends A {",
         "  get v => 0;",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER]);
@@ skipping 542 matching lines @@
         "class A {",
         "  m({a, b}) {}",
         "}",
         "class B extends A {",
         "  m({a, c}) {}",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_NAMED]);
     verify([source]);
   }
-  void test_invalidOverridePositional() {
+  void test_invalidOverridePositional_optional() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m([a, b]) {}",
         "}",
         "class B extends A {",
         "  m([a]) {}",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
     verify([source]);
   }
+  void test_invalidOverridePositional_optionalAndRequired() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m(a, b, [c, d]) {}",
+        "}",
+        "class B extends A {",
+        "  m(a, b, [c]) {}",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
+    verify([source]);
+  }
+  void test_invalidOverridePositional_optionalAndRequired2() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m(a, b, [c, d]) {}",
+        "}",
+        "class B extends A {",
+        "  m(a, [c, d]) {}",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_POSITIONAL]);
+    verify([source]);
+  }
   void test_invalidOverrideRequired() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m(a) {}",
         "}",
         "class B extends A {",
         "  m(a, b) {}",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.INVALID_OVERRIDE_REQUIRED]);
@@ skipping 205 matching lines @@
         "}",
         "abstract class B {",
         "  int x(int a, [int b]);",
         "}",
         "class C implements A, B {",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
   }
+  void test_nonAbstractClassInheritsAbstractMemberOne_setter_excluded() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  final int x = 0;",
+        "}",
+        "class B implements A {",
+        "  int get x => 42;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    verify([source]);
+  }
   void test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface() {
     Source source = addSource(EngineTestCase.createSource([
         "class I {",
         "  set s(int i) {}",
         "}",
         "class C implements I {",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
@@ skipping 360 matching lines @@
   void test_undefinedIdentifier_metadata() {
     Source source = addSource(EngineTestCase.createSource(["@undefined class A {}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_methodInvocation() {
     Source source = addSource(EngineTestCase.createSource(["f() { C.m(); }"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
+  void test_undefinedIdentifier_private_getter() {
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {", "  var _foo;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib.dart';",
+        "class B extends A {",
+        "  test() {",
+        "    var v = _foo;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
+  }
+  void test_undefinedIdentifier_private_setter() {
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {", "  var _foo;", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib.dart';",
+        "class B extends A {",
+        "  test() {",
+        "    _foo = 42;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
+  }
   void test_undefinedNamedParameter() {
     Source source = addSource(EngineTestCase.createSource(["f({a, b}) {}", "main() {", "  f(c: 1);", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_NAMED_PARAMETER]);
   }
   void test_undefinedSetter() {
     Source source1 = addSource2("lib.dart", "");
     Source source2 = addSource2("lib2.dart", EngineTestCase.createSource([
         "import 'lib.dart' as lib;",
         "void f() {",
@@ skipping 82 matching lines @@
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_callParameter);
       });
       _ut.test('test_argumentTypeNotAssignable_invocation_callVariable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_callVariable);
       });
       _ut.test('test_argumentTypeNotAssignable_invocation_functionParameter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_functionParameter);
       });
+      _ut.test('test_argumentTypeNotAssignable_invocation_functionParameter_generic', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_functionParameter_generic);
+      });
       _ut.test('test_argumentTypeNotAssignable_invocation_functionTypes_optional', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_functionTypes_optional);
       });
       _ut.test('test_argumentTypeNotAssignable_invocation_generic', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_generic);
       });
       _ut.test('test_argumentTypeNotAssignable_invocation_named', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 32 matching lines @@
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_new_required);
       });
       _ut.test('test_assignmentToConst_instanceVariable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_assignmentToConst_instanceVariable);
       });
       _ut.test('test_assignmentToConst_localVariable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_assignmentToConst_localVariable);
       });
+      _ut.test('test_assignmentToFinal_excludedSetter', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_assignmentToFinal_excludedSetter);
+      });
       _ut.test('test_assignmentToFinal_instanceVariable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_assignmentToFinal_instanceVariable);
       });
       _ut.test('test_assignmentToFinal_localVariable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_assignmentToFinal_localVariable);
       });
       _ut.test('test_assignmentToFinal_prefixMinusMinus', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 28 matching lines @@
         runJUnitTest(__test, __test.test_caseBlockNotTerminated);
       });
       _ut.test('test_castToNonType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_castToNonType);
       });
       _ut.test('test_concreteClassWithAbstractMember', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_concreteClassWithAbstractMember);
       });
+      _ut.test('test_conflictingDartImport', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_conflictingDartImport);
+      });
       _ut.test('test_conflictingInstanceGetterAndSuperclassMember_direct_field', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_conflictingInstanceGetterAndSuperclassMember_direct_field);
       });
       _ut.test('test_conflictingInstanceGetterAndSuperclassMember_direct_getter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_conflictingInstanceGetterAndSuperclassMember_direct_getter);
       });
       _ut.test('test_conflictingInstanceGetterAndSuperclassMember_direct_method', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 184 matching lines @@
         runJUnitTest(__test, __test.test_invalidOverrideDifferentDefaultValues_positional);
       });
       _ut.test('test_invalidOverrideNamed_fewerNamedParameters', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidOverrideNamed_fewerNamedParameters);
       });
       _ut.test('test_invalidOverrideNamed_missingNamedParameter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidOverrideNamed_missingNamedParameter);
       });
-      _ut.test('test_invalidOverridePositional', () {
+      _ut.test('test_invalidOverridePositional_optional', () {
         final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_invalidOverridePositional);
+        runJUnitTest(__test, __test.test_invalidOverridePositional_optional);
+      });
+      _ut.test('test_invalidOverridePositional_optionalAndRequired', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_invalidOverridePositional_optionalAndRequired);
+      });
+      _ut.test('test_invalidOverridePositional_optionalAndRequired2', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_invalidOverridePositional_optionalAndRequired2);
       });
       _ut.test('test_invalidOverrideRequired', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidOverrideRequired);
       });
       _ut.test('test_invalidSetterOverrideNormalParamType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_invalidSetterOverrideNormalParamType);
       });
       _ut.test('test_listElementTypeNotAssignable', () {
@@ skipping 69 matching lines @@
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_method_fromSuperclass', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_method_fromSuperclass);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_method_optionalParamCount);
       });
+      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_setter_excluded', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_setter_excluded);
+      });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_setter_fromInterface);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_setter_fromSuperclass);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_superclasses_interface', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 168 matching lines @@
         runJUnitTest(__test, __test.test_undefinedIdentifier_initializer_prefix);
       });
       _ut.test('test_undefinedIdentifier_metadata', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_metadata);
       });
       _ut.test('test_undefinedIdentifier_methodInvocation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_methodInvocation);
       });
+      _ut.test('test_undefinedIdentifier_private_getter', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_undefinedIdentifier_private_getter);
+      });
+      _ut.test('test_undefinedIdentifier_private_setter', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_undefinedIdentifier_private_setter);
+      });
       _ut.test('test_undefinedNamedParameter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedNamedParameter);
       });
       _ut.test('test_undefinedSetter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedSetter);
       });
     });
   }
@@ skipping 540 matching lines @@
     ClassElement type = ElementFactory.classElement2(typeName, []);
     LibraryElement importedLibrary = createTestLibrary2(context, "lib", []);
     ((importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [type];
     ImportElementImpl importCore = ElementFactory.importFor(context.getLibraryElement(context.sourceFactory.forUri("dart:core")), null, []);
     ImportElementImpl importLib = ElementFactory.importFor(importedLibrary, null, []);
     LibraryElementImpl importingLibrary = createTestLibrary2(context, "importing", []);
     importingLibrary.imports = <ImportElement> [importCore, importLib];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     JUnitTestCase.assertEquals(type, scope.lookup(ASTFactory.identifier3(typeName), importingLibrary));
-    errorListener.assertNoErrors();
+    errorListener.assertErrors2([StaticWarningCode.CONFLICTING_DART_IMPORT]);
   }
   void test_nonConflictingImports_sameElement() {
     AnalysisContext context = new AnalysisContextImpl();
     String typeNameA = "A";
     String typeNameB = "B";
     ClassElement typeA = ElementFactory.classElement2(typeNameA, []);
     ClassElement typeB = ElementFactory.classElement2(typeNameB, []);
     LibraryElement importedLibrary = createTestLibrary2(context, "imported", []);
     ((importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [typeA, typeB];
     ImportElementImpl import1 = ElementFactory.importFor(importedLibrary, null, []);
@@ skipping 1658 matching lines @@
         "class B<E> {",
         "  E e;",
         "  m() {",
         "    (e as A).a();",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_undefinedGetter_inSubtype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  get b => 0;",
+        "}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    return a.b;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedMethod_assignmentExpression_inSubtype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  operator +(B b) {return new B();}",
+        "}",
+        "f(var a, var a2) {",
+        "  a = new A();",
+        "  a2 = new A();",
+        "  a += a2;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedMethod_inSubtype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  b() {}",
+        "}",
+        "f() {",
+        "  var a = new A();",
+        "  a.b();",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedOperator_binaryExpression_inSubtype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  operator +(B b) {}",
+        "}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    a + 1;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedOperator_indexBoth_inSubtype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  operator [](int index) {}",
+        "}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    a[0]++;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedOperator_indexGetter_inSubtype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  operator [](int index) {}",
+        "}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    a[0];",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedOperator_indexSetter_inSubtype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  operator []=(i, v) {}",
+        "}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    a[0] = 1;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedOperator_postfixExpression() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  operator +(B b) {return new B();}",
+        "}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    a++;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedOperator_prefixExpression() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  operator +(B b) {return new B();}",
+        "}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    ++a;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_undefinedSetter_inSubtype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {}",
+        "class B extends A {",
+        "  set b(x) {}",
+        "}",
+        "f(var a) {",
+        "  if(a is A) {",
+        "    a.b = 0;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
   void test_unnecessaryCast_dynamic_type() {
     Source source = addSource(EngineTestCase.createSource(["m(v) {", "  var b = v as Object;", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_unnecessaryCast_type_dynamic() {
     Source source = addSource(EngineTestCase.createSource(["m(v) {", "  var b = Object as dynamic;", "}"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 125 matching lines @@
         runJUnitTest(__test, __test.test_duplicateImport_show);
       });
       _ut.test('test_overriddingPrivateMember_sameLibrary', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_overriddingPrivateMember_sameLibrary);
       });
       _ut.test('test_overrideEqualsButNotHashCode', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_overrideEqualsButNotHashCode);
       });
+      _ut.test('test_undefinedGetter_inSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedGetter_inSubtype);
+      });
+      _ut.test('test_undefinedMethod_assignmentExpression_inSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedMethod_assignmentExpression_inSubtype);
+      });
+      _ut.test('test_undefinedMethod_inSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedMethod_inSubtype);
+      });
+      _ut.test('test_undefinedOperator_binaryExpression_inSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedOperator_binaryExpression_inSubtype);
+      });
+      _ut.test('test_undefinedOperator_indexBoth_inSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedOperator_indexBoth_inSubtype);
+      });
+      _ut.test('test_undefinedOperator_indexGetter_inSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedOperator_indexGetter_inSubtype);
+      });
+      _ut.test('test_undefinedOperator_indexSetter_inSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedOperator_indexSetter_inSubtype);
+      });
+      _ut.test('test_undefinedOperator_postfixExpression', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedOperator_postfixExpression);
+      });
+      _ut.test('test_undefinedOperator_prefixExpression', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedOperator_prefixExpression);
+      });
+      _ut.test('test_undefinedSetter_inSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_undefinedSetter_inSubtype);
+      });
       _ut.test('test_unnecessaryCast_13855_parameter_A', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unnecessaryCast_13855_parameter_A);
       });
       _ut.test('test_unnecessaryCast_dynamic_type', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unnecessaryCast_dynamic_type);
       });
       _ut.test('test_unnecessaryCast_type_dynamic', () {
         final __test = new NonHintCodeTest();
@@ skipping 1127 matching lines @@
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_setter_inherited);
       });
       _ut.test('test_setter_static', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_setter_static);
       });
     });
   }
 }
+class SubtypeManagerTest extends EngineTestCase {
+
+  /**
+   * The inheritance manager being tested.
+   */
+  SubtypeManager _subtypeManager;
+
+  /**
+   * The compilation unit element containing all of the types setup in each test.
+   */
+  CompilationUnitElementImpl _definingCompilationUnit;
+  void test_computeAllSubtypes_infiniteLoop() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    classA.supertype = classB.type;
+    _definingCompilationUnit.types = <ClassElement> [classA, classB];
+    Set<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
+    List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
+    EngineTestCase.assertSize3(2, subtypesOfA);
+    EngineTestCase.assertContains(arraySubtypesOfA, [classA, classB]);
+  }
+  void test_computeAllSubtypes_manyRecursiveSubtypes() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
+    ClassElementImpl classD = ElementFactory.classElement("D", classB.type, []);
+    ClassElementImpl classE = ElementFactory.classElement("E", classB.type, []);
+    _definingCompilationUnit.types = <ClassElement> [classA, classB, classC, classD, classE];
+    Set<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
+    List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
+    Set<ClassElement> subtypesOfB = _subtypeManager.computeAllSubtypes(classB);
+    List<ClassElement> arraySubtypesOfB = new List.from(subtypesOfB);
+    EngineTestCase.assertSize3(4, subtypesOfA);
+    EngineTestCase.assertContains(arraySubtypesOfA, [classB, classC, classD, classE]);
+    EngineTestCase.assertSize3(3, subtypesOfB);
+    EngineTestCase.assertContains(arraySubtypesOfB, [classC, classD, classE]);
+  }
+  void test_computeAllSubtypes_noSubtypes() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    _definingCompilationUnit.types = <ClassElement> [classA];
+    Set<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
+    EngineTestCase.assertSize3(0, subtypesOfA);
+  }
+  void test_computeAllSubtypes_oneSubtype() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    _definingCompilationUnit.types = <ClassElement> [classA, classB];
+    Set<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
+    List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
+    EngineTestCase.assertSize3(1, subtypesOfA);
+    EngineTestCase.assertContains(arraySubtypesOfA, [classB]);
+  }
+  void setUp() {
+    super.setUp();
+    AnalysisContextImpl context = AnalysisContextFactory.contextWithCore();
+    FileBasedSource source = new FileBasedSource.con1(new ContentCache(), FileUtilities2.createFile("/test.dart"));
+    _definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
+    _definingCompilationUnit.source = source;
+    LibraryElementImpl definingLibrary = ElementFactory.library(context, "test");
+    definingLibrary.definingCompilationUnit = _definingCompilationUnit;
+    _subtypeManager = new SubtypeManager();
+  }
+  static dartSuite() {
+    _ut.group('SubtypeManagerTest', () {
+      _ut.test('test_computeAllSubtypes_infiniteLoop', () {
+        final __test = new SubtypeManagerTest();
+        runJUnitTest(__test, __test.test_computeAllSubtypes_infiniteLoop);
+      });
+      _ut.test('test_computeAllSubtypes_manyRecursiveSubtypes', () {
+        final __test = new SubtypeManagerTest();
+        runJUnitTest(__test, __test.test_computeAllSubtypes_manyRecursiveSubtypes);
+      });
+      _ut.test('test_computeAllSubtypes_noSubtypes', () {
+        final __test = new SubtypeManagerTest();
+        runJUnitTest(__test, __test.test_computeAllSubtypes_noSubtypes);
+      });
+      _ut.test('test_computeAllSubtypes_oneSubtype', () {
+        final __test = new SubtypeManagerTest();
+        runJUnitTest(__test, __test.test_computeAllSubtypes_oneSubtype);
+      });
+    });
+  }
+}
 main() {
 //  ElementResolverTest.dartSuite();
 //  InheritanceManagerTest.dartSuite();
 //  LibraryElementBuilderTest.dartSuite();
 //  LibraryTest.dartSuite();
 //  StaticTypeAnalyzerTest.dartSuite();
+//  SubtypeManagerTest.dartSuite();
 //  TypeOverrideManagerTest.dartSuite();
 //  TypeProviderImplTest.dartSuite();
 //  TypeResolverVisitorTest.dartSuite();
 //  EnclosedScopeTest.dartSuite();
 //  LibraryImportScopeTest.dartSuite();
 //  LibraryScopeTest.dartSuite();
 //  ScopeTest.dartSuite();
 //  CompileTimeErrorCodeTest.dartSuite();
 //  ErrorResolverTest.dartSuite();
 //  HintCodeTest.dartSuite();
 //  MemberMapTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }