Removed fixed dependencies

packages/analyzer/test/generated/non_error_resolver_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-library engine.non_error_resolver_test;
+library analyzer.test.generated.non_error_resolver_test;
 
-import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/source_io.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
-import '../reflective_tests.dart';
 import '../utils.dart';
-import 'resolver_test.dart';
+import 'resolver_test_case.dart';
 import 'test_support.dart';
 
 main() {
   initializeTestEnvironment();
-  runReflectiveTests(NonErrorResolverTest);
+  defineReflectiveTests(NonErrorResolverTest);
 }
 
 @reflectiveTest
 class NonErrorResolverTest extends ResolverTestCase {
   void fail_undefinedEnumConstant() {
     Source source = addSource(r'''
 enum E { ONE }
 E e() {
   return E.TWO;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_abstractSuperMemberReference_superHasNoSuchMethod() {
+    Source source = addSource('''
+abstract class A {
+  int m();
+  noSuchMethod(_) => 42;
+}
+
+class B extends A {
+  int m() => super.m();
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_abstractSuperMemberReference_superSuperHasConcrete_getter() {
+    Source source = addSource('''
+abstract class A {
+  int get m => 0;
+}
+
+abstract class B extends A {
+  int get m;
+}
+
+class C extends B {
+  int get m => super.m;
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_abstractSuperMemberReference_superSuperHasConcrete_method() {
+    Source source = addSource('''
+void main() {
+  print(new C().m());
+}
+
+abstract class A {
+  int m() => 0;
+}
+
+abstract class B extends A {
+  int m();
+}
+
+class C extends B {
+  int m() => super.m();
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_abstractSuperMemberReference_superSuperHasConcrete_setter() {
+    Source source = addSource('''
+abstract class A {
+  void set m(int v) {}
+}
+
+abstract class B extends A {
+  void set m(int v);
+}
+
+class C extends B {
+  void set m(int v) {
+    super.m = 0;
+  }
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_ambiguousExport() {
     Source source = addSource(r'''
 library L;
 export 'lib1.dart';
 export 'lib2.dart';''');
     addNamedSource(
         "/lib1.dart",
         r'''
 library lib1;
 class M {}''');
@@ skipping 112 matching lines @@
 library lib1;
 class N {}
 class N1 {}''');
     addNamedSource(
         "/lib2.dart",
         r'''
 library lib2;
 class N {}
 class N2 {}''');
     computeLibrarySourceErrors(source);
+    assertErrors(source, [HintCode.UNUSED_SHOWN_NAME]);
+  }
+
+  void test_annotated_partOfDeclaration() {
+    Source source = addSource('library L; part "part.dart";');
+    addNamedSource('/part.dart', '@deprecated part of L;');
+    computeLibrarySourceErrors(source);
     assertNoErrors(source);
+    verify([source]);
   }
 
   void test_argumentTypeNotAssignable_classWithCall_Function() {
     Source source = addSource(r'''
   caller(Function callee) {
     callee();
   }
 
   class CallMeBack {
     call() => 0;
@@ skipping 74 matching lines @@
     Source source = addSource(r'''
 typedef A(int p1, String p2);
 f(A a) {
   a(1, '2');
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_assert_with_message_await() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableAssertMessage = true);
+    Source source = addSource('''
+import 'dart:async';
+f() async {
+  assert(false, await g());
+}
+Future<String> g() => null;
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_assert_with_message_dynamic() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableAssertMessage = true);
+    Source source = addSource('''
+f() {
+  assert(false, g());
+}
+g() => null;
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_assert_with_message_non_string() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableAssertMessage = true);
+    Source source = addSource('''
+f() {
+  assert(false, 3);
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_assert_with_message_null() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableAssertMessage = true);
+    Source source = addSource('''
+f() {
+  assert(false, null);
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_assert_with_message_string() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableAssertMessage = true);
+    Source source = addSource('''
+f() {
+  assert(false, 'message');
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_assert_with_message_suppresses_unused_var_hint() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableAssertMessage = true);
+    Source source = addSource('''
+f() {
+  String message = 'msg';
+  assert(true, message);
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_assignability_function_expr_rettype_from_typedef_cls() {
     // In the code below, the type of (() => f()) has a return type which is
     // a class, and that class is inferred from the return type of the typedef
     // F.
     Source source = addSource('''
 class C {}
 typedef C F();
 F f;
 main() {
   F f2 = (() => f());
@@ skipping 556 matching lines @@
   switch(s) {
     case('1') : return 1;
     default: return 0;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_class_type_alias_documentationComment() {
+    Source source = addSource('''
+/**
+ * Documentation
+ */
+class C = D with E;
+
+class D {}
+class E {}''');
+    computeLibrarySourceErrors(source);
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = _getResolvedLibraryUnit(source);
+    ClassElement classC = unit.element.getType('C');
+    expect(classC.documentationComment, isNotNull);
+  }
+
   void test_commentReference_beforeConstructor() {
     String code = r'''
 abstract class A {
   /// [p]
   A(int p) {}
 }''';
     Source source = addSource(code);
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = _getResolvedLibraryUnit(source);
     {
-      SimpleIdentifier ref = EngineTestCase.findNode(
-          unit, code, "p]", (node) => node is SimpleIdentifier);
-      EngineTestCase.assertInstanceOf((obj) => obj is ParameterElement,
-          ParameterElement, ref.staticElement);
+      SimpleIdentifier ref =
+          EngineTestCase.findSimpleIdentifier(unit, code, "p]");
+      expect(ref.staticElement, new isInstanceOf<ParameterElement>());
     }
   }
 
   void test_commentReference_beforeEnum() {
     String code = r'''
 /// This is the [Samurai] kind.
 enum Samurai {
   /// Use [int].
   WITH_SWORD,
   /// Like [WITH_SWORD], but only without one.
   WITHOUT_SWORD
 }''';
     Source source = addSource(code);
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = _getResolvedLibraryUnit(source);
     {
-      SimpleIdentifier ref = EngineTestCase.findNode(
-          unit, code, "Samurai]", (node) => node is SimpleIdentifier);
+      SimpleIdentifier ref =
+          EngineTestCase.findSimpleIdentifier(unit, code, 'Samurai]');
       ClassElement refElement = ref.staticElement;
       expect(refElement, isNotNull);
       expect(refElement.name, 'Samurai');
     }
     {
-      SimpleIdentifier ref = EngineTestCase.findNode(
-          unit, code, "int]", (node) => node is SimpleIdentifier);
+      SimpleIdentifier ref =
+          EngineTestCase.findSimpleIdentifier(unit, code, 'int]');
       ClassElement refElement = ref.staticElement;
       expect(refElement, isNotNull);
       expect(refElement.name, 'int');
     }
     {
-      SimpleIdentifier ref = EngineTestCase.findNode(
-          unit, code, "WITH_SWORD]", (node) => node is SimpleIdentifier);
+      SimpleIdentifier ref =
+          EngineTestCase.findSimpleIdentifier(unit, code, 'WITH_SWORD]');
       PropertyAccessorElement refElement = ref.staticElement;
       expect(refElement, isNotNull);
       expect(refElement.name, 'WITH_SWORD');
     }
   }
 
   void test_commentReference_beforeFunction_blockBody() {
     String code = r'''
 /// [p]
 foo(int p) {
 }''';
     Source source = addSource(code);
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = _getResolvedLibraryUnit(source);
-    SimpleIdentifier ref = EngineTestCase.findNode(
-        unit, code, "p]", (node) => node is SimpleIdentifier);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ParameterElement, ParameterElement, ref.staticElement);
+    SimpleIdentifier ref =
+        EngineTestCase.findSimpleIdentifier(unit, code, 'p]');
+    expect(ref.staticElement, new isInstanceOf<ParameterElement>());
   }
 
   void test_commentReference_beforeFunction_expressionBody() {
     String code = r'''
 /// [p]
 foo(int p) => null;''';
     Source source = addSource(code);
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = _getResolvedLibraryUnit(source);
-    SimpleIdentifier ref = EngineTestCase.findNode(
-        unit, code, "p]", (node) => node is SimpleIdentifier);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ParameterElement, ParameterElement, ref.staticElement);
+    SimpleIdentifier ref =
+        EngineTestCase.findSimpleIdentifier(unit, code, 'p]');
+    expect(ref.staticElement, new isInstanceOf<ParameterElement>());
+  }
+
+  void test_commentReference_beforeFunctionTypeAlias() {
+    String code = r'''
+/// [p]
+typedef Foo(int p);
+''';
+    Source source = addSource(code);
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = _getResolvedLibraryUnit(source);
+    SimpleIdentifier ref =
+        EngineTestCase.findSimpleIdentifier(unit, code, 'p]');
+    expect(ref.staticElement, new isInstanceOf<ParameterElement>());
+  }
+
+  void test_commentReference_beforeGetter() {
+    String code = r'''
+abstract class A {
+  /// [int]
+  get g => null;
+}''';
+    Source source = addSource(code);
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = _getResolvedLibraryUnit(source);
+    {
+      SimpleIdentifier ref =
+          EngineTestCase.findSimpleIdentifier(unit, code, 'int]');
+      expect(ref.staticElement, isNotNull);
+    }
   }
 
   void test_commentReference_beforeMethod() {
     String code = r'''
 abstract class A {
   /// [p1]
   ma(int p1) {}
   /// [p2]
   mb(int p2);
+  /// [p3] and [p4]
+  mc(int p3, p4());
+  /// [p5]
+  md(int p5, {int p6});
 }''';
     Source source = addSource(code);
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = _getResolvedLibraryUnit(source);
-    {
-      SimpleIdentifier ref = EngineTestCase.findNode(
-          unit, code, "p1]", (node) => node is SimpleIdentifier);
-      EngineTestCase.assertInstanceOf((obj) => obj is ParameterElement,
-          ParameterElement, ref.staticElement);
+    assertIsParameter(String search) {
+      SimpleIdentifier ref =
+          EngineTestCase.findSimpleIdentifier(unit, code, search);
+      expect(ref.staticElement, new isInstanceOf<ParameterElement>());
     }
-    {
-      SimpleIdentifier ref = EngineTestCase.findNode(
-          unit, code, "p2]", (node) => node is SimpleIdentifier);
-      EngineTestCase.assertInstanceOf((obj) => obj is ParameterElement,
-          ParameterElement, ref.staticElement);
-    }
+
+    assertIsParameter('p1');
+    assertIsParameter('p2');
+    assertIsParameter('p3');
+    assertIsParameter('p4');
+    assertIsParameter('p5');
+    assertIsParameter('p6');
   }
 
   void test_commentReference_class() {
     String code = r'''
 /// [foo]
 class A {
   foo() {}
 }''';
     Source source = addSource(code);
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = _getResolvedLibraryUnit(source);
-    SimpleIdentifier ref = EngineTestCase.findNode(
-        unit, code, "foo]", (node) => node is SimpleIdentifier);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is MethodElement, MethodElement, ref.staticElement);
+    SimpleIdentifier ref =
+        EngineTestCase.findSimpleIdentifier(unit, code, 'foo]');
+    expect(ref.staticElement, new isInstanceOf<MethodElement>());
   }
 
   void test_commentReference_setter() {
     String code = r'''
 class A {
   /// [x] in A
   mA() {}
   set x(value) {}
 }
 class B extends A {
   /// [x] in B
   mB() {}
 }
 ''';
     Source source = addSource(code);
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = _getResolvedLibraryUnit(source);
     {
-      SimpleIdentifier ref = EngineTestCase.findNode(
-          unit, code, "x] in A", (node) => node is SimpleIdentifier);
-      EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccessorElement,
-          PropertyAccessorElement, ref.staticElement);
+      SimpleIdentifier ref =
+          EngineTestCase.findSimpleIdentifier(unit, code, "x] in A");
+      expect(ref.staticElement, new isInstanceOf<PropertyAccessorElement>());
     }
     {
-      SimpleIdentifier ref = EngineTestCase.findNode(
-          unit, code, "x] in B", (node) => node is SimpleIdentifier);
-      EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccessorElement,
-          PropertyAccessorElement, ref.staticElement);
+      SimpleIdentifier ref =
+          EngineTestCase.findSimpleIdentifier(unit, code, 'x] in B');
+      expect(ref.staticElement, new isInstanceOf<PropertyAccessorElement>());
     }
   }
 
   void test_concreteClassWithAbstractMember() {
     Source source = addSource(r'''
 abstract class A {
   m();
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
@@ skipping 328 matching lines @@
   void test_constNotInitialized_local() {
     Source source = addSource(r'''
 main() {
   const int x = 0;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_constRedirectSkipsSupertype() {
+    // Since C redirects to C.named, it doesn't implicitly refer to B's
+    // unnamed constructor.  Therefore there is no cycle.
+    Source source = addSource('''
+class B {
+  final x;
+  const B() : x = y;
+  const B.named() : x = null;
+}
+class C extends B {
+  const C() : this.named();
+  const C.named() : super.named();
+}
+const y = const C();
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_constructorDeclaration_scope_signature() {
     Source source = addSource(r'''
 const app = 0;
 class A {
   A(@app int app) {}
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_constWithNonConstantArgument_constField() {
+    Source source = addSource(r'''
+class A {
+  const A(x);
+}
+main() {
+  const A(double.INFINITY);
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_constWithNonConstantArgument_literals() {
     Source source = addSource(r'''
 class A {
   const A(a, b, c, d);
 }
 f() { return const A(true, 0, 1.0, '2'); }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 480 matching lines @@
 class A implements Function {
   noSuchMethod(inv) {
     return 42;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_functionWithoutCall_withNoSuchMethod_mixin() {
+    Source source = addSource(r'''
+class A {
+  noSuchMethod(inv) {}
+}
+class B extends Object with A implements Function {
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_functionWithoutCall_withNoSuchMethod_superclass() {
+    Source source = addSource(r'''
+class A {
+  noSuchMethod(inv) {}
+}
+class B extends A implements Function {
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_implicitConstructorDependencies() {
     // No warning should be generated for the code below; this requires that
     // implicit constructors are generated for C1 before C2, even though C1
     // follows C2 in the file.  See dartbug.com/21600.
     Source source = addSource(r'''
 class B {
   B(int i);
 }
 class M1 {}
 class M2 {}
@@ skipping 762 matching lines @@
   g = () => 0;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_invalidFactoryNameNotAClass() {
     Source source = addSource(r'''
 class A {
-  factory A() {}
+  factory A() => null;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_invalidIdentifierInAsync() {
     Source source = addSource(r'''
 class A {
   m() {
@@ skipping 314 matching lines @@
 class B extends A {
   g() {
     f();
   }
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_invocationOfNonFunction_functionTypeTypeParameter() {
+    Source source = addSource(r'''
+typedef void Action<T>(T x);
+class C<T, U extends Action<T>> {
+  T value;
+  U action;
+  C(this.value, [this.action]);
+  void act() {
+    action(value);
+  }
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_invocationOfNonFunction_getter() {
     Source source = addSource(r'''
 class A {
   var g;
 }
 f() {
   A a;
   a.g();
 }''');
     computeLibrarySourceErrors(source);
@@ skipping 309 matching lines @@
 }
 class B extends Object with A {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_mixinDeclaresConstructor_factory() {
     Source source = addSource(r'''
 class A {
-  factory A() {}
+  factory A() => null;
 }
 class B extends Object with A {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_mixinInheritsFromNotObject_classDeclaration_extends() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableSuperMixins = true;
@@ skipping 146 matching lines @@
   A() {}
 }
 f() {
   new A();
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_abstractsDontOverrideConcretes_getter() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_abstractsDontOverrideConcretes_getter() {
     Source source = addSource(r'''
 class A {
   int get g => 0;
 }
 abstract class B extends A {
   int get g;
 }
 class C extends B {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_abstractsDontOverrideConcretes_method() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_abstractsDontOverrideConcretes_method() {
     Source source = addSource(r'''
 class A {
   m(p) {}
 }
 abstract class B extends A {
   m(p);
 }
 class C extends B {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_abstractsDontOverrideConcretes_setter() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_abstractsDontOverrideConcretes_setter() {
     Source source = addSource(r'''
 class A {
   set s(v) {}
 }
 abstract class B extends A {
   set s(v);
 }
 class C extends B {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_interface() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_interface() {
     // 15979
     Source source = addSource(r'''
 abstract class M {}
 abstract class A {}
 abstract class I {
   m();
 }
 abstract class B = A with M implements I;''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_mixin() {
     // 15979
     Source source = addSource(r'''
 abstract class M {
   m();
 }
 abstract class A {}
 abstract class B = A with M;''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_superclass() {
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_classTypeAlias_superclass() {
     // 15979
     Source source = addSource(r'''
 class M {}
 abstract class A {
   m();
 }
 abstract class B = A with M;''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 64 matching lines @@
   m(p);
 }
 class B extends A {
   noSuchMethod(v) => '';
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_overridesMethodInObject() {
+  void test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_mixin() {
+    Source source = addSource(r'''
+class A {
+  noSuchMethod(v) => '';
+}
+class B extends Object with A {
+  m(p);
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_superclass() {
+    Source source = addSource(r'''
+class A {
+  noSuchMethod(v) => '';
+}
+class B extends A {
+  m(p);
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void
+      test_nonAbstractClassInheritsAbstractMemberOne_overridesMethodInObject() {
     Source source = addSource(r'''
 class A {
   String toString([String prefix = '']) => '${prefix}Hello';
 }
 class C {}
 class B extends A with C {}''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 25 matching lines @@
   !true;
   !false;
   !pb;
   !pd;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_nonBoolNegationExpression_dynamic() {
+    Source source = addSource(r'''
+f1(bool dynamic) {
+  !dynamic;
+}
+f2() {
+  bool dynamic = true;
+  !dynamic;
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_nonBoolOperand_and_bool() {
     Source source = addSource(r'''
 bool f(bool left, bool right) {
   return left && right;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 20 matching lines @@
   void test_nonBoolOperand_or_dynamic() {
     Source source = addSource(r'''
 bool f(dynamic left, right) {
   return left || right;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_nonConstantDefaultValue_constField() {
+    Source source = addSource(r'''
+f([a = double.INFINITY]) {
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_nonConstantDefaultValue_function_named() {
     Source source = addSource("f({x : 2 + 3}) {}");
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_nonConstantDefaultValue_function_positional() {
     Source source = addSource("f([x = 2 + 3]) {}");
     computeLibrarySourceErrors(source);
@@ skipping 34 matching lines @@
   void test_nonConstantDefaultValue_method_positional() {
     Source source = addSource(r'''
 class A {
   m([x = 2 + 3]) {}
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_nonConstantDefaultValue_typedConstList() {
+    Source source = addSource(r'''
+class A {
+  m([p111 = const <String>[]]) {}
+}
+class B extends A {
+  m([p222 = const <String>[]]) {}
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_nonConstantValueInInitializer_namedArgument() {
     Source source = addSource(r'''
 class A {
   final a;
   const A({this.a});
 }
 class B extends A {
   const B({b}) : super(a: b);
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_nonConstCaseExpression() {
+  void test_nonConstCaseExpression_constField() {
+    Source source = addSource(r'''
+f(double p) {
+  switch (p) {
+    case double.INFINITY:
+      return true;
+    default:
+      return false;
+  }
+}''');
+    computeLibrarySourceErrors(source);
+    assertErrors(
+        source, [CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
+
+  void test_nonConstCaseExpression_typeLiteral() {
     Source source = addSource(r'''
 f(Type t) {
   switch (t) {
     case bool:
     case int:
       return true;
     default:
       return false;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_nonConstListElement_constField() {
+    Source source = addSource(r'''
+main() {
+  const [double.INFINITY];
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_nonConstMapAsExpressionStatement_const() {
     Source source = addSource(r'''
 f() {
   const {'a' : 0, 'b' : 1};
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 10 matching lines @@
   void test_nonConstMapAsExpressionStatement_typeArguments() {
     Source source = addSource(r'''
 f() {
   <String, int> {'a' : 0, 'b' : 1};
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_nonConstMapKey_constField() {
+    Source source = addSource(r'''
+main() {
+  const {double.INFINITY: 0};
+}''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source,
+        [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
+    verify([source]);
+  }
+
+  void test_nonConstMapValue_constField() {
+    Source source = addSource(r'''
+main() {
+  const {0: double.INFINITY};
+}''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_nonConstValueInInitializer_binary_bool() {
     Source source = addSource(r'''
 class A {
   final v;
   const A.a1(bool p) : v = p && true;
   const A.a2(bool p) : v = true && p;
   const A.b1(bool p) : v = p || true;
   const A.b2(bool p) : v = true || p;
 }''');
     computeLibrarySourceErrors(source);
@@ skipping 126 matching lines @@
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_nonGenerativeConstructor() {
     Source source = addSource(r'''
 class A {
   A.named() {}
-  factory A() {}
+  factory A() => null;
 }
 class B extends A {
   B() : super.named();
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_nonTypeInCatchClause_isClass() {
@@ skipping 397 matching lines @@
 
   void test_recursiveFactoryRedirect() {
     Source source = addSource(r'''
 class A {
   factory A() = B;
 }
 class B implements A {
   factory B() = C;
 }
 class C implements B {
-  factory C() {}
+  factory C() => null;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_redirectToInvalidFunctionType() {
     Source source = addSource(r'''
 class A implements B {
   A(int p) {}
@@ skipping 398 matching lines @@
     Source source = addSource(r'''
 class A {}
 class B extends A {}
 class G<E extends A> {}
 f() { return new G<B>(); }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_typeArgumentNotMatchingBounds_ofFunctionTypeAlias_hasBound() {
+    Source source = addSource(r'''
+class A {}
+class B extends A {}
+typedef F<T extends A>();
+F<A> fa;
+F<B> fb;
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_typeArgumentNotMatchingBounds_ofFunctionTypeAlias_hasBound2() {
+    Source source = addSource(r'''
+class MyClass<T> {}
+typedef MyFunction<T, P extends MyClass<T>>();
+class A<T, P extends MyClass<T>> {
+  MyFunction<T, P> f;
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_typeArgumentNotMatchingBounds_ofFunctionTypeAlias_noBound() {
+    Source source = addSource(r'''
+typedef F<T>();
+F<int> f1;
+F<String> f2;
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_typeArgumentNotMatchingBounds_typeArgumentList_0() {
     Source source = addSource("abstract class A<T extends A>{}");
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_typeArgumentNotMatchingBounds_typeArgumentList_1() {
     Source source = addSource("abstract class A<T extends A<A>>{}");
     computeLibrarySourceErrors(source);
@@ skipping 12 matching lines @@
   void test_typePromotion_booleanAnd_useInRight() {
     Source source = addSource(r'''
 main(Object p) {
   p is String && p.length != 0;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_typePromotion_booleanAnd_useInRight_accessedInClosureRight_noAssignment() {
+  void
+      test_typePromotion_booleanAnd_useInRight_accessedInClosureRight_noAssignment() {
     Source source = addSource(r'''
 callMe(f()) { f(); }
 main(Object p) {
   (p is String) && callMe(() { p.length; });
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 16 matching lines @@
   void test_typePromotion_conditional_useInThen() {
     Source source = addSource(r'''
 main(Object p) {
   p is String ? p.length : 0;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_typePromotion_conditional_useInThen_accessedInClosure_noAssignment() {
+  void
+      test_typePromotion_conditional_useInThen_accessedInClosure_noAssignment() {
     Source source = addSource(r'''
 callMe(f()) { f(); }
 main(Object p) {
   p is String ? callMe(() { p.length; }) : 0;
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
@@ skipping 377 matching lines @@
 class B extends A<List> {
   m() {
     element.last;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_undefinedIdentifier_hide() {
-    Source source = addSource(r'''
-library L;
-export 'lib1.dart' hide a;''');
-    addNamedSource("/lib1.dart", "library lib1;");
-    computeLibrarySourceErrors(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
-  void test_undefinedIdentifier_show() {
-    Source source = addSource(r'''
-library L;
-export 'lib1.dart' show a;''');
-    addNamedSource("/lib1.dart", "library lib1;");
-    computeLibrarySourceErrors(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
   void test_undefinedIdentifier_synthetic_whenExpression() {
     Source source = addSource(r'''
 print(x) {}
 main() {
   print(is String);
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [ParserErrorCode.MISSING_IDENTIFIER]);
   }
 
@@ skipping 132 matching lines @@
   A.named() {}
 }
 /// [new A] or [new A.named]
 main() {
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_unusedShownName_unresolved() {
+    Source source = addSource(r'''
+import 'dart:math' show max, FooBar;
+main() {
+  print(max(1, 2));
+}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [HintCode.UNDEFINED_SHOWN_NAME]);
+  }
+
   void test_uriDoesNotExist_dll() {
     addNamedSource("/lib.dll", "");
     Source source = addSource("import 'dart-ext:lib';");
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
   void test_uriDoesNotExist_dylib() {
     addNamedSource("/lib.dylib", "");
     Source source = addSource("import 'dart-ext:lib';");
@@ skipping 322 matching lines @@
     reset();
   }
 
   void _check_wrongNumberOfParametersForOperator1(String name) {
     _check_wrongNumberOfParametersForOperator(name, "a");
   }
 
   CompilationUnit _getResolvedLibraryUnit(Source source) =>
       analysisContext.getResolvedCompilationUnit2(source, source);
 }