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 406 matching lines @@
         "class A {}",
         "class B extends A {",
         "  B m() => this;",
         "}",
         "A f(A p) {",
         "  if (p is B) {",
         "    return p.m();",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+    assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.thenStatement as Block)).statements[0] as ReturnStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     JUnitTestCase.assertNotNull(invocation.methodName.propagatedElement);
   }
   void test_is_while() {
     Source source = addSource(EngineTestCase.createSource([
@@ skipping 1928 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedSetter() {
     Source source = addSource(EngineTestCase.createSource(["int get x => 0;", "set x(v) {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_mixedReturnTypes_differentScopes() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class C {",
+        "  m(int x) {",
+        "    f(int y) {",
+        "      return;",
+        "    }",
+        "    f(x);",
+        "    return 0;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_mixedReturnTypes_sameKind() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class C {",
+        "  m(int x) {",
+        "    if (x < 0) {",
+        "      return 1;",
+        "    }",
+        "    return 0;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_mixinDeclaresConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {}",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 95 matching lines @@
         "}",
         "abstract class B extends A {",
         "  m(p);",
         "}",
         "class C extends B {",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_accessor() {
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A {",
+        "  int get g;",
+        "}",
+        "class B extends A {",
+        "  noSuchMethod(v) => '';",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_method() {
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A {",
+        "  m(p);",
+        "}",
+        "class B extends A {",
+        "  noSuchMethod(v) => '';",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_nonBoolExpression_functionType() {
     Source source = addSource(EngineTestCase.createSource([
         "bool makeAssertion() => true;",
         "f() {",
         "  assert(makeAssertion);",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 336 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() {
+  void test_propagateTypeArgs_intoBounds() {
     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_propagateTypeArgs_intoSupertype() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A<T> {",
+        "  A(T p);",
+        "  A.named(T p);",
+        "}",
+        "class B<S> extends A<S> {",
+        "  B(S p) : super(p);",
+        "  B.named(S p) : super.named(p);",
+        "}"]));
+    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 328 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_returnClass_withTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef B A();", "class B {", "  A a;", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
-  void test_typeAliasCannotReferenceItself_typeParameterBounds() {
-    Source source = addSource(EngineTestCase.createSource(["typedef A<T extends A>();"]));
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
   void test_typeArgumentNotMatchingBounds_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "class G<E extends A> {",
         "  const G();",
         "}",
         "f() { return const G<B>(); }"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 20 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_typeArgumentNotMatchingBounds_typeArgumentList_20() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A<T extends A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A>>>>>>>>>>>>>>>>>>>>>{}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_typePromotion_booleanAnd_useInRight() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  p is String && p.length != 0;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_booleanAnd_useInRight_accessedInClosureRight_noAssignment() {
+    Source source = addSource(EngineTestCase.createSource([
+        "callMe(f()) { f(); }",
+        "main(Object p) {",
+        "  (p is String) && callMe(() { p.length; });",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_conditional_useInThen() {
+    Source source = addSource(EngineTestCase.createSource(["main(Object p) {", "  p is String ? p.length : 0;", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_conditional_useInThen_accessedInClosure_noAssignment() {
+    Source source = addSource(EngineTestCase.createSource([
+        "callMe(f()) { f(); }",
+        "main(Object p) {",
+        "  p is String ? callMe(() { p.length; }) : 0;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_functionType_arg_ignoreIfNotMoreSpecific() {
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef FuncB(B b);",
+        "typedef FuncA(A a);",
+        "class A {}",
+        "class B {}",
+        "main(FuncA f) {",
+        "  if (f is FuncB) {",
+        "    f(new A());",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_functionType_return_ignoreIfNotMoreSpecific() {
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef FuncDynToDyn(x);",
+        "typedef void FuncDynToVoid(x);",
+        "class A {}",
+        "main(FuncDynToDyn f) {",
+        "  if (f is FuncDynToVoid) {",
+        "    A a = f(null);",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_functionType_return_voidToDynamic() {
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef FuncDynToDyn(x);",
+        "typedef void FuncDynToVoid(x);",
+        "class A {}",
+        "main(FuncDynToVoid f) {",
+        "  if (f is FuncDynToDyn) {",
+        "    A a = f(null);",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_accessedInClosure_noAssignment() {
+    Source source = addSource(EngineTestCase.createSource([
+        "callMe(f()) { f(); }",
+        "main(Object p) {",
+        "  if (p is String) {",
+        "    callMe(() {",
+        "      p.length;",
+        "    });",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_hasAssignment_outsideAfter() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  if (p is String) {",
+        "    p.length;",
+        "  }",
+        "  p = 0;",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_hasAssignment_outsideBefore() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p, Object p2) {",
+        "  p = p2;",
+        "  if (p is String) {",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_is_and_left() {
+    Source source = addSource(EngineTestCase.createSource([
+        "bool tt() => true;",
+        "main(Object p) {",
+        "  if (p is String && tt()) {",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_is_and_right() {
+    Source source = addSource(EngineTestCase.createSource([
+        "bool tt() => true;",
+        "main(Object p) {",
+        "  if (tt() && p is String) {",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_is_and_subThenSuper() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  var a;",
+        "}",
+        "class B extends A {",
+        "  var b;",
+        "}",
+        "main(Object p) {",
+        "  if (p is B && p is A) {",
+        "    p.a;",
+        "    p.b;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_is_parenthesized() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  if ((p is String)) {",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_is_single() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  if (p is String) {",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_undefinedConstructorInInitializer_explicit_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.named() {}",
         "}",
         "class B extends A {",
         "  B() : super.named();",
         "}"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 790 matching lines @@
         runJUnitTest(__test, __test.test_misMatchedGetterAndSetterTypes_topLevel_sameTypes);
       });
       _ut.test('test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedGetter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedGetter);
       });
       _ut.test('test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedSetter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_misMatchedGetterAndSetterTypes_topLevel_unspecifiedSetter);
       });
+      _ut.test('test_mixedReturnTypes_differentScopes', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_mixedReturnTypes_differentScopes);
+      });
+      _ut.test('test_mixedReturnTypes_sameKind', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_mixedReturnTypes_sameKind);
+      });
       _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_mixTypeAlias', () {
         final __test = new NonErrorResolverTest();
@@ skipping 24 matching lines @@
         runJUnitTest(__test, __test.test_newWithUndefinedConstructorDefault);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method);
       });
+      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_accessor', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_accessor);
+      });
+      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_method', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_method);
+      });
       _ut.test('test_nonBoolExpression_functionType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonBoolExpression_functionType);
       });
       _ut.test('test_nonBoolExpression_interfaceType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonBoolExpression_interfaceType);
       });
       _ut.test('test_nonConstCaseExpression', () {
         final __test = new NonErrorResolverTest();
@@ skipping 124 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', () {
+      _ut.test('test_propagateTypeArgs_intoBounds', () {
         final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_propagateTypeArgsIntoBounds);
+        runJUnitTest(__test, __test.test_propagateTypeArgs_intoBounds);
+      });
+      _ut.test('test_propagateTypeArgs_intoSupertype', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_propagateTypeArgs_intoSupertype);
       });
       _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', () {
@@ skipping 89 matching lines @@
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_propertyAccess_propertyAccessor);
       });
       _ut.test('test_superInInvalidContext', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_superInInvalidContext);
       });
       _ut.test('test_typeAliasCannotReferenceItself_returnClass_withTypeAlias', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnClass_withTypeAlias);
       });
-      _ut.test('test_typeAliasCannotReferenceItself_typeParameterBounds', () {
-        final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_typeParameterBounds);
-      });
       _ut.test('test_typeArgumentNotMatchingBounds_const', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_new', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_0', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_0);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_1', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_1);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_20', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_typeArgumentList_20);
       });
+      _ut.test('test_typePromotion_booleanAnd_useInRight', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_booleanAnd_useInRight);
+      });
+      _ut.test('test_typePromotion_booleanAnd_useInRight_accessedInClosureRight_noAssignment', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_booleanAnd_useInRight_accessedInClosureRight_noAssignment);
+      });
+      _ut.test('test_typePromotion_conditional_useInThen', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_conditional_useInThen);
+      });
+      _ut.test('test_typePromotion_conditional_useInThen_accessedInClosure_noAssignment', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_conditional_useInThen_accessedInClosure_noAssignment);
+      });
+      _ut.test('test_typePromotion_functionType_arg_ignoreIfNotMoreSpecific', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_functionType_arg_ignoreIfNotMoreSpecific);
+      });
+      _ut.test('test_typePromotion_functionType_return_ignoreIfNotMoreSpecific', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_functionType_return_ignoreIfNotMoreSpecific);
+      });
+      _ut.test('test_typePromotion_functionType_return_voidToDynamic', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_functionType_return_voidToDynamic);
+      });
+      _ut.test('test_typePromotion_if_accessedInClosure_noAssignment', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_accessedInClosure_noAssignment);
+      });
+      _ut.test('test_typePromotion_if_hasAssignment_outsideAfter', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_outsideAfter);
+      });
+      _ut.test('test_typePromotion_if_hasAssignment_outsideBefore', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_outsideBefore);
+      });
+      _ut.test('test_typePromotion_if_is_and_left', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_is_and_left);
+      });
+      _ut.test('test_typePromotion_if_is_and_right', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_is_and_right);
+      });
+      _ut.test('test_typePromotion_if_is_and_subThenSuper', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_is_and_subThenSuper);
+      });
+      _ut.test('test_typePromotion_if_is_parenthesized', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_is_parenthesized);
+      });
+      _ut.test('test_typePromotion_if_is_single', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_is_single);
+      });
       _ut.test('test_undefinedConstructorInInitializer_explicit_named', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_named);
       });
       _ut.test('test_undefinedConstructorInInitializer_explicit_unnamed', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_unnamed);
       });
       _ut.test('test_undefinedConstructorInInitializer_hasOptionalParameters', () {
         final __test = new NonErrorResolverTest();
@@ skipping 751 matching lines @@
     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_typePromotion_booleanAnd_useInRight_accessedInClosureRight_mutated() {
+    Source source = addSource(EngineTestCase.createSource([
+        "callMe(f()) { f(); }",
+        "main(Object p) {",
+        "  (p is String) && callMe(() { p.length; });",
+        "  p = 0;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_booleanAnd_useInRight_mutatedInLeft() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  ((p is String) && ((p = 42) == 42)) && p.length != 0;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_booleanAnd_useInRight_mutatedInRight() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  (p is String) && (((p = 42) == 42) && p.length != 0);",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_conditional_useInThen_accessedInClosure_hasAssignment_after() {
+    Source source = addSource(EngineTestCase.createSource([
+        "callMe(f()) { f(); }",
+        "main(Object p) {",
+        "  p is String ? callMe(() { p.length; }) : 0;",
+        "  p = 42;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_conditional_useInThen_accessedInClosure_hasAssignment_before() {
+    Source source = addSource(EngineTestCase.createSource([
+        "callMe(f()) { f(); }",
+        "main(Object p) {",
+        "  p = 42;",
+        "  p is String ? callMe(() { p.length; }) : 0;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_conditional_useInThen_hasAssignment() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  p is String ? (p.length + (p = 42)) : 0;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_accessedInClosure_hasAssignment() {
+    Source source = addSource(EngineTestCase.createSource([
+        "callMe(f()) { f(); }",
+        "main(Object p) {",
+        "  if (p is String) {",
+        "    callMe(() {",
+        "      p.length;",
+        "    });",
+        "  }",
+        "  p = 0;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_and_right_hasAssignment() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  if (p is String && (p = null) == null) {",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_hasAssignment_after() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  if (p is String) {",
+        "    p.length;",
+        "    p = 0;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_hasAssignment_before() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  if (p is String) {",
+        "    p = 0;",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
   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 37 matching lines @@
         "  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]);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_indexGetter() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0];", "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_indexSetter() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "f(A a) {", "  a[0] = 1;", "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
@@ skipping 347 matching lines @@
         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_typePromotion_booleanAnd_useInRight_accessedInClosureRight_mutated', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_booleanAnd_useInRight_accessedInClosureRight_mutated);
+      });
+      _ut.test('test_typePromotion_booleanAnd_useInRight_mutatedInLeft', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_booleanAnd_useInRight_mutatedInLeft);
+      });
+      _ut.test('test_typePromotion_booleanAnd_useInRight_mutatedInRight', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_booleanAnd_useInRight_mutatedInRight);
+      });
+      _ut.test('test_typePromotion_conditional_useInThen_accessedInClosure_hasAssignment_after', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_conditional_useInThen_accessedInClosure_hasAssignment_after);
+      });
+      _ut.test('test_typePromotion_conditional_useInThen_accessedInClosure_hasAssignment_before', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_conditional_useInThen_accessedInClosure_hasAssignment_before);
+      });
+      _ut.test('test_typePromotion_conditional_useInThen_hasAssignment', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_conditional_useInThen_hasAssignment);
+      });
+      _ut.test('test_typePromotion_if_accessedInClosure_hasAssignment', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_accessedInClosure_hasAssignment);
+      });
+      _ut.test('test_typePromotion_if_and_right_hasAssignment', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_and_right_hasAssignment);
+      });
+      _ut.test('test_typePromotion_if_hasAssignment_after', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_after);
+      });
+      _ut.test('test_typePromotion_if_hasAssignment_before', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_before);
+      });
       _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();
@@ skipping 489 matching lines @@
   }
   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]);
+    assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
   void test_undefinedOperator_indexGetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "f(var a) {",
         "  if(a is A) {",
         "    a[0];",
         "  }",
         "}"]));
     resolve(source);
@@ skipping 459 matching lines @@
     LibraryElementImpl element = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     _library.libraryElement = element;
     _typeProvider = new TestTypeProvider();
     _visitor = new TypeResolverVisitor.con1(_library, librarySource, _typeProvider);
   }
   void test_visitCatchClause_exception() {
     CatchClause clause = ASTFactory.catchClause("e", []);
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl(exceptionParameter);
-    resolve(clause, _typeProvider.objectType, null, []);
+    resolve(clause, _typeProvider.dynamicType, null, []);
     _listener.assertNoErrors();
   }
   void test_visitCatchClause_exception_stackTrace() {
     CatchClause clause = ASTFactory.catchClause2("e", "s", []);
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl(exceptionParameter);
     SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
     stackTraceParameter.staticElement = new LocalVariableElementImpl(stackTraceParameter);
-    resolve(clause, _typeProvider.objectType, _typeProvider.stackTraceType, []);
+    resolve(clause, _typeProvider.dynamicType, _typeProvider.stackTraceType, []);
     _listener.assertNoErrors();
   }
   void test_visitCatchClause_on_exception() {
     ClassElement exceptionElement = ElementFactory.classElement2("E", []);
     TypeName exceptionType = ASTFactory.typeName(exceptionElement, []);
     CatchClause clause = ASTFactory.catchClause4(exceptionType, "e", []);
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl(exceptionParameter);
     resolve(clause, exceptionElement.type, null, [exceptionElement]);
     _listener.assertNoErrors();
@@ skipping 142 matching lines @@
    * Analyze the given catch clause and assert that the types of the parameters have been set to the
    * given types. The types can be null if the catch clause does not have the corresponding
    * parameter.
    *
    * @param node the catch clause to be analyzed
    * @param exceptionType the expected type of the exception parameter
    * @param stackTraceType the expected type of the stack trace parameter
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    */
-  void resolve(CatchClause node, InterfaceType exceptionType, InterfaceType stackTraceType, List<Element> definedElements) {
+  void resolve(CatchClause node, Type2 exceptionType, InterfaceType stackTraceType, List<Element> definedElements) {
     resolveNode(node, definedElements);
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       JUnitTestCase.assertSame(exceptionType, exceptionParameter.staticType);
     }
     SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
     if (stackTraceParameter != null) {
       JUnitTestCase.assertSame(stackTraceType, stackTraceParameter.staticType);
     }
   }
@@ skipping 1667 matching lines @@
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
     verify([source]);
   }
   void test_defaultValueInFunctionTypedParameter_optional() {
     Source source = addSource(EngineTestCase.createSource(["f(g([p = null])) {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
     verify([source]);
   }
+  void test_defaultValueInRedirectingFactoryConstructor() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  factory A([int x = 0]) = B;",
+        "}",
+        "",
+        "class B implements A {",
+        "  B([int x = 1]) {}",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR]);
+    verify([source]);
+  }
   void test_duplicateConstructorName_named() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A.a() {}", "  A.a() {}", "}"]));
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME,
         CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME]);
     verify([source]);
   }
   void test_duplicateConstructorName_unnamed() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "  A() {}", "}"]));
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT,
         CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT]);
     verify([source]);
   }
   void test_duplicateDefinition() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  int m = 0;", "  m(a) {}", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_acrossLibraries() {
     Source librarySource = addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';", "part 'b.dart';"]));
     Source sourceA = addSource2("/a.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
     Source sourceB = addSource2("/b.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
     resolve(librarySource);
     assertErrors(sourceB, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([librarySource, sourceA, sourceB]);
   }
   void test_duplicateDefinition_classMembers_fields() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int a;", "  int a;", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_classMembers_fields_oneStatic() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  static int x;", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_classMembers_methods() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {}", "  m() {}", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_localFields() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  m() {",
         "    int a;",
         "    int a;",
         "  }",
         "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_parameterWithFunctionName_local() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  f(f) {}", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinition_parameterWithFunctionName_topLevel() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  f(f) {}", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.DUPLICATE_DEFINITION,
-        CompileTimeErrorCode.DUPLICATE_DEFINITION]);
+    assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
     verify([source]);
   }
   void test_duplicateDefinitionInheritance_instanceGetter_staticGetter() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get x => 0;",
         "}",
         "class B extends A {",
         "  static int get x => 0;",
         "}"]));
@@ skipping 305 matching lines @@
   }
   void test_finalNotInitialized_local_const() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  const int x;", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
     verify([source]);
   }
   void test_getterAndMethodWithSameName() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  x(y) {}", "  get x => 0;", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME,
-        CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME]);
     verify([source]);
   }
   void test_implementsDisallowedClass_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A implements bool {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_implementsDisallowedClass_double() {
     Source source = addSource(EngineTestCase.createSource(["class A implements double {}"]));
@@ skipping 499 matching lines @@
     Source source = addSource(EngineTestCase.createSource(["class A {", "  get A => 0;", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
     verify([source]);
   }
   void test_memberWithClassName_method() {
   }
   void test_methodAndGetterWithSameName() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  get x => 0;", "  x(y) {}", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME,
-        CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME]);
+    assertErrors(source, [CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME]);
     verify([source]);
   }
   void test_mixinDeclaresConstructor_classDeclaration() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
         "class B extends Object with A {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
@@ skipping 670 matching lines @@
   void test_redirectToNonConstConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.a() {}",
         "  const factory A.b() = A.a;",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR]);
     verify([source]);
   }
+  void test_referencedBeforeDeclaration_hideInBlock_function() {
+    Source source = addSource(EngineTestCase.createSource([
+        "var v = 1;",
+        "main() {",
+        "  print(v);",
+        "  v() {}",
+        "}",
+        "print(x) {}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
+  }
+  void test_referencedBeforeDeclaration_hideInBlock_local() {
+    Source source = addSource(EngineTestCase.createSource([
+        "var v = 1;",
+        "main() {",
+        "  print(v);",
+        "  var v = 2;",
+        "}",
+        "print(x) {}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
+  }
+  void test_referencedBeforeDeclaration_hideInBlock_subBlock() {
+    Source source = addSource(EngineTestCase.createSource([
+        "var v = 1;",
+        "main() {",
+        "  {",
+        "    print(v);",
+        "  }",
+        "  var v = 2;",
+        "}",
+        "print(x) {}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
+  }
   void test_referenceToDeclaredVariableInInitializer_closure() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  var x = (x) {};", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_referenceToDeclaredVariableInInitializer_getter() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  int x = x + 1;", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
@@ skipping 166 matching lines @@
     verify([source]);
   }
   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_typeAliasCannotReferenceItself_typeVariableBounds() {
+    Source source = addSource(EngineTestCase.createSource(["typedef A<T extends A>();"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    verify([source]);
+  }
   void test_typeAliasCannotRereferenceItself_mixin_direct() {
     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([
         "class M1 = Object with M2;",
         "class M2 = Object with M1;"]));
@@ skipping 508 matching lines @@
         runJUnitTest(__test, __test.test_defaultValueInFunctionTypeAlias);
       });
       _ut.test('test_defaultValueInFunctionTypedParameter_named', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_defaultValueInFunctionTypedParameter_named);
       });
       _ut.test('test_defaultValueInFunctionTypedParameter_optional', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_defaultValueInFunctionTypedParameter_optional);
       });
+      _ut.test('test_defaultValueInRedirectingFactoryConstructor', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_defaultValueInRedirectingFactoryConstructor);
+      });
       _ut.test('test_duplicateConstructorName_named', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateConstructorName_named);
       });
       _ut.test('test_duplicateConstructorName_unnamed', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_duplicateConstructorName_unnamed);
       });
       _ut.test('test_duplicateDefinition', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 776 matching lines @@
         runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_getter);
       });
       _ut.test('test_referenceToDeclaredVariableInInitializer_setter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_setter);
       });
       _ut.test('test_referenceToDeclaredVariableInInitializer_unqualifiedInvocation', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_unqualifiedInvocation);
       });
+      _ut.test('test_referencedBeforeDeclaration_hideInBlock_function', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_referencedBeforeDeclaration_hideInBlock_function);
+      });
+      _ut.test('test_referencedBeforeDeclaration_hideInBlock_local', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_referencedBeforeDeclaration_hideInBlock_local);
+      });
+      _ut.test('test_referencedBeforeDeclaration_hideInBlock_subBlock', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_referencedBeforeDeclaration_hideInBlock_subBlock);
+      });
       _ut.test('test_rethrowOutsideCatch', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_rethrowOutsideCatch);
       });
       _ut.test('test_returnInGenerativeConstructor', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_returnInGenerativeConstructor);
       });
       _ut.test('test_returnInGenerativeConstructor_expressionFunctionBody', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 60 matching lines @@
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnClass_withTypeAlias);
       });
       _ut.test('test_typeAliasCannotReferenceItself_returnType', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnType);
       });
       _ut.test('test_typeAliasCannotReferenceItself_returnType_indirect', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnType_indirect);
       });
+      _ut.test('test_typeAliasCannotReferenceItself_typeVariableBounds', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_typeVariableBounds);
+      });
       _ut.test('test_typeAliasCannotRereferenceItself_mixin_direct', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotRereferenceItself_mixin_direct);
       });
       _ut.test('test_typeAliasCannotRereferenceItself_mixin_indirect', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotRereferenceItself_mixin_indirect);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_const', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 303 matching lines @@
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_conditional_and_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  return (n is int && n > 0) ? n & 0x0F : 0;",
         "}"]));
     resolve(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertNoErrors(source);
   }
   void test_conditional_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  return (n is int) ? n & 0x0F : 0;",
         "}"]));
     resolve(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertNoErrors(source);
   }
   void test_conditional_isNot() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  return (n is! int) ? 0 : n & 0x0F;",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
   void test_conditional_or_is() {
@@ skipping 17 matching lines @@
   }
   void test_if_and_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  if (n is int && n > 0) {",
         "    return n & 0x0F;",
         "  }",
         "  return 0;",
         "}"]));
     resolve(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertNoErrors(source);
   }
   void test_if_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  if (n is int) {",
         "    return n & 0x0F;",
         "  }",
         "  return 0;",
         "}"]));
     resolve(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertNoErrors(source);
   }
   void test_if_isNot() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  if (n is! int) {",
         "    return 0;",
         "  } else {",
         "    return n & 0x0F;",
         "  }",
         "}"]));
@@ skipping 991 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_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]);
-    verify([source]);
-  }
-  void fail_commentReferenceUndeclaredConstructor() {
-    Source source = addSource(EngineTestCase.createSource([]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_CONSTRUCTOR]);
-    verify([source]);
-  }
-  void fail_commentReferenceUndeclaredIdentifier() {
-    Source source = addSource(EngineTestCase.createSource([]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_IDENTIFIER]);
-    verify([source]);
-  }
-  void fail_commentReferenceUriNotLibrary() {
-    Source source = addSource(EngineTestCase.createSource([]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.COMMENT_REFERENCE_URI_NOT_LIBRARY]);
-    verify([source]);
-  }
-  void fail_mismatchedAccessorTypes_getterAndSuperSetter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int get g { return 0; }",
-        "  set g(int v) {}",
-        "}",
-        "class B extends A {",
-        "  set g(String v) {}",
-        "}"]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
-    verify([source]);
-  }
-  void fail_mismatchedAccessorTypes_superGetterAndSetter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int get g { return 0; }",
-        "  set g(int v) {}",
-        "}",
-        "class B extends A {",
-        "  String get g { return ''; }",
-        "}"]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
-    verify([source]);
-  }
   void fail_undefinedGetter() {
     Source source = addSource(EngineTestCase.createSource([]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_GETTER]);
     verify([source]);
   }
   void fail_undefinedIdentifier_commentReference() {
     Source source = addSource(EngineTestCase.createSource(["/** [m] xxx [new B.c] */", "class A {", "}"]));
     resolve(source);
     assertErrors(source, [
@@ skipping 390 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 768 matching lines @@
   void test_mismatchedAccessorTypes_class() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get g { return 0; }",
         "  set g(String v) {}",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
+  void test_mismatchedAccessorTypes_getterAndSuperSetter() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int get g { return 0; }",
+        "}",
+        "class B extends A {",
+        "  set g(String v) {}",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE]);
+    verify([source]);
+  }
+  void test_mismatchedAccessorTypes_setterAndSuperGetter() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  set g(int v) {}",
+        "}",
+        "class B extends A {",
+        "  String get g { return ''; }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE]);
+    verify([source]);
+  }
   void test_mismatchedAccessorTypes_topLevel() {
     Source source = addSource(EngineTestCase.createSource(["int get g { return 0; }", "set g(String v) {}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
+  void test_mixedReturnTypes_localFunction() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class C {",
+        "  m(int x) {",
+        "    return (int y) {",
+        "      if (y < 0) {",
+        "        return;",
+        "      }",
+        "      return 0;",
+        "    };",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.MIXED_RETURN_TYPES]);
+    verify([source]);
+  }
+  void test_mixedReturnTypes_method() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class C {",
+        "  m(int x) {",
+        "    if (x < 0) {",
+        "      return;",
+        "    }",
+        "    return 0;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.MIXED_RETURN_TYPES]);
+    verify([source]);
+  }
+  void test_mixedReturnTypes_topLevelFunction() {
+    Source source = addSource(EngineTestCase.createSource([
+        "f(int x) {",
+        "  if (x < 0) {",
+        "    return;",
+        "  }",
+        "  return 0;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.MIXED_RETURN_TYPES]);
+    verify([source]);
+  }
   void test_newWithAbstractClass() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {}",
         "void f() {",
         "  A a = new A();",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NEW_WITH_ABSTRACT_CLASS]);
     verify([source]);
   }
@@ skipping 147 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 254 matching lines @@
     resolve(source);
     assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
   void test_typeParameterReferencedByStatic_setter() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static set s(K k) {}", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
+  void test_typePromotion_functionType_arg_InterToDyn() {
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef FuncDyn(x);",
+        "typedef FuncA(A a);",
+        "class A {}",
+        "class B {}",
+        "main(FuncA f) {",
+        "  if (f is FuncDyn) {",
+        "    f(new B());",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+  }
   void test_typeTestNonType() {
     Source source = addSource(EngineTestCase.createSource(["var A = 0;", "f(var p) {", "  if (p is A) {", "  }", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.TYPE_TEST_NON_TYPE]);
     verify([source]);
   }
   void test_undefinedClass_instanceCreation() {
     Source source = addSource(EngineTestCase.createSource(["f() { new C(); }"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_CLASS]);
@@ skipping 30 matching lines @@
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_function_prefix() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "int a() => b;", "b.C c;"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
     verify([source]);
   }
-  void test_undefinedIdentifier_hideInBlock_function() {
-    Source source = addSource(EngineTestCase.createSource([
-        "var v = 1;",
-        "main() {",
-        "  print(v);",
-        "  v() {}",
-        "}",
-        "print(x) {}"]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
-  }
-  void test_undefinedIdentifier_hideInBlock_local() {
-    Source source = addSource(EngineTestCase.createSource([
-        "var v = 1;",
-        "main() {",
-        "  print(v);",
-        "  var v = 2;",
-        "}",
-        "print(x) {}"]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
-  }
-  void test_undefinedIdentifier_hideInBlock_subBlock() {
-    Source source = addSource(EngineTestCase.createSource([
-        "var v = 1;",
-        "main() {",
-        "  {",
-        "    print(v);",
-        "  }",
-        "  var v = 2;",
-        "}",
-        "print(x) {}"]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
-  }
   void test_undefinedIdentifier_initializer() {
     Source source = addSource(EngineTestCase.createSource(["var a = b;"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_initializer_prefix() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "var a = b;", "b.C c;"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
@@ skipping 183 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 284 matching lines @@
         runJUnitTest(__test, __test.test_mapKeyTypeNotAssignable);
       });
       _ut.test('test_mapValueTypeNotAssignable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_mapValueTypeNotAssignable);
       });
       _ut.test('test_mismatchedAccessorTypes_class', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_mismatchedAccessorTypes_class);
       });
+      _ut.test('test_mismatchedAccessorTypes_getterAndSuperSetter', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_mismatchedAccessorTypes_getterAndSuperSetter);
+      });
+      _ut.test('test_mismatchedAccessorTypes_setterAndSuperGetter', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_mismatchedAccessorTypes_setterAndSuperGetter);
+      });
       _ut.test('test_mismatchedAccessorTypes_topLevel', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_mismatchedAccessorTypes_topLevel);
       });
+      _ut.test('test_mixedReturnTypes_localFunction', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_mixedReturnTypes_localFunction);
+      });
+      _ut.test('test_mixedReturnTypes_method', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_mixedReturnTypes_method);
+      });
+      _ut.test('test_mixedReturnTypes_topLevelFunction', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_mixedReturnTypes_topLevelFunction);
+      });
       _ut.test('test_newWithAbstractClass', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithAbstractClass);
       });
       _ut.test('test_newWithInvalidTypeParameters', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_newWithInvalidTypeParameters);
       });
       _ut.test('test_newWithInvalidTypeParameters_tooFew', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 40 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 108 matching lines @@
         runJUnitTest(__test, __test.test_typeParameterReferencedByStatic_methodParameter);
       });
       _ut.test('test_typeParameterReferencedByStatic_methodReturn', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_typeParameterReferencedByStatic_methodReturn);
       });
       _ut.test('test_typeParameterReferencedByStatic_setter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_typeParameterReferencedByStatic_setter);
       });
+      _ut.test('test_typePromotion_functionType_arg_InterToDyn', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_functionType_arg_InterToDyn);
+      });
       _ut.test('test_typeTestNonType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_typeTestNonType);
       });
       _ut.test('test_undefinedClassBoolean_variableDeclaration', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedClassBoolean_variableDeclaration);
       });
       _ut.test('test_undefinedClass_instanceCreation', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 12 matching lines @@
         runJUnitTest(__test, __test.test_undefinedIdentifier_for);
       });
       _ut.test('test_undefinedIdentifier_function', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_function);
       });
       _ut.test('test_undefinedIdentifier_function_prefix', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_function_prefix);
       });
-      _ut.test('test_undefinedIdentifier_hideInBlock_function', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_undefinedIdentifier_hideInBlock_function);
-      });
-      _ut.test('test_undefinedIdentifier_hideInBlock_local', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_undefinedIdentifier_hideInBlock_local);
-      });
-      _ut.test('test_undefinedIdentifier_hideInBlock_subBlock', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_undefinedIdentifier_hideInBlock_subBlock);
-      });
       _ut.test('test_undefinedIdentifier_initializer', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_initializer);
       });
       _ut.test('test_undefinedIdentifier_initializer_prefix', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_initializer_prefix);
       });
       _ut.test('test_undefinedIdentifier_metadata', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 2229 matching lines @@
   void test_overrideEqualsButNotHashCode() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  bool operator ==(x) {}",
         "  get hashCode => 0;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
-  void test_unnecessaryCast_13855_parameter_A() {
+  void test_proxy_annotation_prefixed() {
     Source source = addSource(EngineTestCase.createSource([
-        "class A{",
-        "  a() {}",
-        "}",
-        "class B<E> {",
-        "  E e;",
-        "  m() {",
-        "    (e as A).a();",
+        "library L;",
+        "import 'meta.dart';",
+        "@proxy",
+        "class A {}",
+        "f(var a) {",
+        "  a = new A();",
+        "  a.m();",
+        "  var x = a.g;",
+        "  a.s = 1;",
+        "  var y = a + a;",
+        "  a++;",
+        "  ++a;",
+        "}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_proxy_annotation_prefixed2() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'meta.dart';",
+        "@proxy",
+        "class A {}",
+        "class B {",
+        "  f(var a) {",
+        "    a = new A();",
+        "    a.m();",
+        "    var x = a.g;",
+        "    a.s = 1;",
+        "    var y = a + a;",
+        "    a++;",
+        "    ++a;",
         "  }",
         "}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
     resolve(source);
     assertNoErrors(source);
-    verify([source]);
+  }
+  void test_proxy_annotation_prefixed3() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'meta.dart';",
+        "class B {",
+        "  f(var a) {",
+        "    a = new A();",
+        "    a.m();",
+        "    var x = a.g;",
+        "    a.s = 1;",
+        "    var y = a + a;",
+        "    a++;",
+        "    ++a;",
+        "  }",
+        "}",
+        "@proxy",
+        "class A {}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
+    resolve(source);
+    assertNoErrors(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;",
@@ skipping 120 matching lines @@
         "  set b(x) {}",
         "}",
         "f(var a) {",
         "  if(a is A) {",
         "    a.b = 0;",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
   }
+  void test_unnecessaryCast_13855_parameter_A() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A{",
+        "  a() {}",
+        "}",
+        "class B<E> {",
+        "  E e;",
+        "  m() {",
+        "    (e as A).a();",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_unnecessaryCast_dynamic_type() {
     Source source = addSource(EngineTestCase.createSource(["m(v) {", "  var b = v as Object;", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_unnecessaryCast_type_dynamic() {
     Source source = addSource(EngineTestCase.createSource(["m(v) {", "  var b = Object as dynamic;", "}"]));
     resolve(source);
     assertNoErrors(source);
@@ 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_proxy_annotation_prefixed', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_proxy_annotation_prefixed);
+      });
+      _ut.test('test_proxy_annotation_prefixed2', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_proxy_annotation_prefixed2);
+      });
+      _ut.test('test_proxy_annotation_prefixed3', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_proxy_annotation_prefixed3);
+      });
       _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();
@@ skipping 63 matching lines @@
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport_prefix_topLevelFunction);
       });
     });
   }
 }
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     LibraryElement definingLibrary2 = createTestLibrary();
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
-    Scope rootScope = new Scope_20(definingLibrary2, errorListener2);
+    Scope rootScope = new Scope_22(definingLibrary2, errorListener2);
     EnclosedScope scope = new EnclosedScope(rootScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
     errorListener2.assertErrors3([ErrorSeverity.ERROR]);
   }
   void test_define_normal() {
     LibraryElement definingLibrary3 = createTestLibrary();
     GatheringErrorListener errorListener3 = new GatheringErrorListener();
-    Scope rootScope = new Scope_21(definingLibrary3, errorListener3);
+    Scope rootScope = new Scope_23(definingLibrary3, errorListener3);
     EnclosedScope outerScope = new EnclosedScope(rootScope);
     EnclosedScope innerScope = new EnclosedScope(outerScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v2"));
     outerScope.define(element1);
     innerScope.define(element2);
     errorListener3.assertNoErrors();
   }
   static dartSuite() {
     _ut.group('EnclosedScopeTest', () {
       _ut.test('test_define_duplicate', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_duplicate);
       });
       _ut.test('test_define_normal', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_normal);
       });
     });
   }
 }
-class Scope_20 extends Scope {
+class Scope_22 extends Scope {
   LibraryElement definingLibrary2;
   GatheringErrorListener errorListener2;
-  Scope_20(this.definingLibrary2, this.errorListener2) : super();
+  Scope_22(this.definingLibrary2, this.errorListener2) : super();
   LibraryElement get definingLibrary => definingLibrary2;
   AnalysisErrorListener get errorListener => errorListener2;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
-class Scope_21 extends Scope {
+class Scope_23 extends Scope {
   LibraryElement definingLibrary3;
   GatheringErrorListener errorListener3;
-  Scope_21(this.definingLibrary3, this.errorListener3) : super();
+  Scope_23(this.definingLibrary3, this.errorListener3) : super();
   LibraryElement get definingLibrary => definingLibrary3;
   AnalysisErrorListener get errorListener => errorListener3;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 class LibraryElementBuilderTest extends EngineTestCase {
 
   /**
    * The source factory used to create [Source].
    */
   SourceFactory _sourceFactory;
@@ skipping 1148 matching lines @@
 //  HintCodeTest.dartSuite();
 //  MemberMapTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }