diff --git a/pkg/analyzer/lib/src/summary/link.dart b/pkg/analyzer/lib/src/summary/link.dart
index 4fdd614..59f4e77 100644
--- a/pkg/analyzer/lib/src/summary/link.dart
+++ b/pkg/analyzer/lib/src/summary/link.dart
@@ -1555,6 +1555,9 @@
     for (ClassElementForLink classElement in types) {
       classElement.link(this);
     }
+    for (ClassElementForLink classElement in mixins) {
+      classElement.link(this);
+    }
   }
 
   /// Throw away any information stored in the summary by a previous call to
diff --git a/pkg/analyzer/lib/src/task/strong_mode.dart b/pkg/analyzer/lib/src/task/strong_mode.dart
index f3fffb3..a0b6100 100644
--- a/pkg/analyzer/lib/src/task/strong_mode.dart
+++ b/pkg/analyzer/lib/src/task/strong_mode.dart
@@ -78,14 +78,8 @@
    * compilation [unit].
    */
   void inferCompilationUnit(CompilationUnitElement unit) {
-    for (ClassElement classElement in unit.types) {
-      try {
-        _inferClass(classElement);
-      } on _CycleException {
-        // This is a short circuit return to prevent types that inherit from
-        // types containing a circular reference from being inferred.
-      }
-    }
+    _inferClasses(unit.mixins);
+    _inferClasses(unit.types);
   }
 
   /**
@@ -306,6 +300,7 @@
         _inferType(classElement.supertype);
         classElement.mixins.forEach(_inferType);
         classElement.interfaces.forEach(_inferType);
+        classElement.superclassConstraints.forEach(_inferType);
         //
         // Then infer the types for the members.
         //
@@ -330,6 +325,17 @@
     }
   }
 
+  void _inferClasses(List<ClassElement> elements) {
+    for (ClassElement element in elements) {
+      try {
+        _inferClass(element);
+      } on _CycleException {
+        // This is a short circuit return to prevent types that inherit from
+        // types containing a circular reference from being inferred.
+      }
+    }
+  }
+
   void _inferConstructorFieldFormals(ConstructorElement constructor) {
     for (ParameterElement parameter in constructor.parameters) {
       if (parameter.hasImplicitType &&
diff --git a/pkg/analyzer/test/src/dart/resolution/class_test.dart b/pkg/analyzer/test/src/dart/resolution/class_test.dart
index 8384f10..7edebf0 100644
--- a/pkg/analyzer/test/src/dart/resolution/class_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/class_test.dart
@@ -70,7 +70,10 @@
 ''');
     await resolveTestFile();
     assertTestErrors([CompileTimeErrorCode.ABSTRACT_SUPER_MEMBER_REFERENCE]);
-    assertElement(findNode.simple('foo(); // ref'), findElement.method('foo'));
+    assertElement(
+      findNode.simple('foo(); // ref'),
+      findElement.method('foo', of: 'A'),
+    );
   }
 
   test_abstractSuperMemberReference_method_reference() async {
@@ -110,7 +113,7 @@
     assertNoTestErrors();
     assertElement(
       findNode.simple('foo(); // ref'),
-      findElement.method('foo', className: 'M'),
+      findElement.method('foo', of: 'M'),
     );
   }
 
@@ -137,7 +140,7 @@
     assertNoTestErrors();
     assertElement(
       findNode.simple('foo(); // ref'),
-      findElement.method('foo', className: 'B'),
+      findElement.method('foo', of: 'B'),
     );
   }
 
@@ -161,7 +164,7 @@
     assertNoTestErrors();
     assertElement(
       findNode.simple('foo(); // ref'),
-      findElement.method('foo', className: 'A'),
+      findElement.method('foo', of: 'A'),
     );
   }
 
@@ -207,7 +210,7 @@
     assertNoTestErrors();
     assertElement(
       findNode.simple('foo(); // ref'),
-      findElement.method('foo', className: 'A'),
+      findElement.method('foo', of: 'A'),
     );
   }
 
diff --git a/pkg/analyzer/test/src/dart/resolution/find_element.dart b/pkg/analyzer/test/src/dart/resolution/find_element.dart
index 105b4a4..fe7cb76 100644
--- a/pkg/analyzer/test/src/dart/resolution/find_element.dart
+++ b/pkg/analyzer/test/src/dart/resolution/find_element.dart
@@ -149,17 +149,37 @@
     return result;
   }
 
-  MethodElement method(String name, {String className}) {
-    for (var class_ in unitElement.types) {
-      if (className != null && class_.name != className) {
-        continue;
-      }
-      for (var method in class_.methods) {
+  MethodElement method(String name, {String of}) {
+    MethodElement result;
+
+    void findIn(List<MethodElement> methods) {
+      for (var method in methods) {
         if (method.name == name) {
-          return method;
+          if (result != null) {
+            throw new StateError('Method name $name is not unique.');
+          }
+          result = method;
         }
       }
     }
+
+    for (var class_ in unitElement.types) {
+      if (of != null && class_.name != of) {
+        continue;
+      }
+      findIn(class_.methods);
+    }
+
+    for (var mixin in unitElement.mixins) {
+      if (of != null && mixin.name != of) {
+        continue;
+      }
+      findIn(mixin.methods);
+    }
+
+    if (result != null) {
+      return result;
+    }
     fail('Not found class method: $name');
   }
 
diff --git a/pkg/analyzer/test/src/dart/resolution/instance_member_inference_class_test.dart b/pkg/analyzer/test/src/dart/resolution/instance_member_inference_class_test.dart
new file mode 100644
index 0000000..1218643
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/resolution/instance_member_inference_class_test.dart
@@ -0,0 +1,296 @@
+// Copyright (c) 2018, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'driver_resolution.dart';
+import 'resolution.dart';
+import 'task_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(InstanceMemberInferenceClassDriverResolutionTest);
+    defineReflectiveTests(InstanceMemberInferenceClassTaskResolutionTest);
+  });
+}
+
+@reflectiveTest
+class InstanceMemberInferenceClassDriverResolutionTest
+    extends DriverResolutionTest with InstanceMemberInferenceClassMixin {}
+
+abstract class InstanceMemberInferenceClassMixin implements ResolutionTest {
+  test_invalid_inheritanceCycle() async {
+    addTestFile('''
+class A extends C {}
+class B extends A {}
+class C extends B {}
+''');
+    await resolveTestFile();
+  }
+
+  test_method_parameter_multiple_different() async {
+    addTestFile('''
+class A {
+  foo(int p) => 0;
+}
+class B {
+  foo(double p) => 0;
+}
+class C implements A, B {
+  foo(p) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'C').parameters[0];
+    assertElementTypeDynamic(p.type);
+  }
+
+  test_method_parameter_multiple_named_different() async {
+    addTestFile('''
+class A {
+  foo({int p}) => 0;
+}
+class B {
+  foo({int q}) => 0;
+}
+class C implements A, B {
+  foo({p}) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'C').parameters[0];
+    assertElementTypeDynamic(p.type);
+  }
+
+  test_method_parameter_multiple_named_same() async {
+    addTestFile('''
+class A {
+  foo({int p}) => 0;
+}
+class B {
+  foo({int p}) => 0;
+}
+class C implements A, B {
+  foo({p}) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'C').parameters[0];
+    assertElementTypeString(p.type, 'int');
+  }
+
+  test_method_parameter_multiple_namedAndRequired() async {
+    addTestFile('''
+class A {
+  foo({int p}) => 0;
+}
+class B {
+  foo(int p) => 0;
+}
+class C implements A, B {
+  foo(p) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'C').parameters[0];
+    assertElementTypeDynamic(p.type);
+  }
+
+  test_method_parameter_multiple_optionalAndRequired() async {
+    addTestFile('''
+class A {
+  foo(int p) => 0;
+}
+class B {
+  foo([int p]) => 0;
+}
+class C implements A, B {
+  foo(p) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'C').parameters[0];
+    assertElementTypeString(p.type, 'int');
+  }
+
+  test_method_parameter_single_generic() async {
+    addTestFile('''
+class A<E> {
+  foo(E p) => 0;
+}
+class C<T> implements A<T> {
+  foo(p) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'C').parameters[0];
+    assertElementTypeString(p.type, 'T');
+  }
+
+  test_method_return_multiple_different() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B {
+  double foo() => 0.0;
+}
+class C implements A, B {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'C');
+    assertElementTypeDynamic(foo.returnType);
+  }
+
+  test_method_return_multiple_different_generic() async {
+    addTestFile('''
+class A<E> {
+  E foo() => null;
+}
+class B<E> {
+  E foo() => null;
+}
+class C implements A<int>, B<double> {
+  foo() => null;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'C');
+    assertElementTypeDynamic(foo.returnType);
+  }
+
+  test_method_return_multiple_different_void() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B {
+  void foo() => 0;
+}
+class C implements A, B {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'C');
+    assertElementTypeDynamic(foo.returnType);
+  }
+
+  test_method_return_multiple_dynamic() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B {
+  foo() => 0;
+}
+class C implements A, B {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'C');
+    assertElementTypeDynamic(foo.returnType);
+  }
+
+  test_method_return_multiple_same_generic() async {
+    addTestFile('''
+class A<E> {
+  E foo() => 0;
+}
+class B<E> {
+  E foo() => 0;
+}
+class C<T> implements A<T>, B<T> {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'C');
+    assertElementTypeString(foo.returnType, 'T');
+  }
+
+  test_method_return_multiple_same_nonVoid() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B {
+  int foo() => 0;
+}
+class C implements A, B {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'C');
+    assertElementTypeString(foo.returnType, 'int');
+  }
+
+  test_method_return_multiple_same_void() async {
+    addTestFile('''
+class A {
+  void foo() {};
+}
+class B {
+  void foo() {};
+}
+class C implements A, B {
+  foo() {};
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'C');
+    assertElementTypeString(foo.returnType, 'void');
+  }
+
+  test_method_return_single() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B extends A {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'B');
+    assertElementTypeString(foo.returnType, 'int');
+  }
+
+  test_method_return_single_generic() async {
+    addTestFile('''
+class A<E> {
+  E foo() => 0;
+}
+class B<T> extends A<T> {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'B');
+    assertElementTypeString(foo.returnType, 'T');
+  }
+}
+
+@reflectiveTest
+class InstanceMemberInferenceClassTaskResolutionTest extends TaskResolutionTest
+    with InstanceMemberInferenceClassMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/instance_member_inference_mixin_test.dart b/pkg/analyzer/test/src/dart/resolution/instance_member_inference_mixin_test.dart
new file mode 100644
index 0000000..387e166
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/resolution/instance_member_inference_mixin_test.dart
@@ -0,0 +1,296 @@
+// Copyright (c) 2018, 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.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'driver_resolution.dart';
+import 'resolution.dart';
+import 'task_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(InstanceMemberInferenceMixinDriverResolutionTest);
+    defineReflectiveTests(InstanceMemberInferenceMixinTaskResolutionTest);
+  });
+}
+
+@reflectiveTest
+class InstanceMemberInferenceMixinDriverResolutionTest
+    extends DriverResolutionTest with InstanceMemberInferenceMixinMixin {}
+
+abstract class InstanceMemberInferenceMixinMixin implements ResolutionTest {
+  test_invalid_inheritanceCycle() async {
+    addTestFile('''
+mixin A on C {}
+mixin B on A {}
+mixin C on B {}
+''');
+    await resolveTestFile();
+  }
+
+  test_method_parameter_multiple_different() async {
+    addTestFile('''
+class A {
+  foo(int p) => 0;
+}
+class B {
+  foo(double p) => 0;
+}
+mixin M on A, B {
+  foo(p) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'M').parameters[0];
+    assertElementTypeDynamic(p.type);
+  }
+
+  test_method_parameter_multiple_named_different() async {
+    addTestFile('''
+class A {
+  foo({int p}) => 0;
+}
+class B {
+  foo({int q}) => 0;
+}
+mixin M on A, B {
+  foo({p}) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'M').parameters[0];
+    assertElementTypeDynamic(p.type);
+  }
+
+  test_method_parameter_multiple_named_same() async {
+    addTestFile('''
+class A {
+  foo({int p}) => 0;
+}
+class B {
+  foo({int p}) => 0;
+}
+mixin M on A, B {
+  foo({p}) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'M').parameters[0];
+    assertElementTypeString(p.type, 'int');
+  }
+
+  test_method_parameter_multiple_namedAndRequired() async {
+    addTestFile('''
+class A {
+  foo({int p}) => 0;
+}
+class B {
+  foo(int p) => 0;
+}
+mixin M on A, B {
+  foo(p) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'M').parameters[0];
+    assertElementTypeDynamic(p.type);
+  }
+
+  test_method_parameter_multiple_optionalAndRequired() async {
+    addTestFile('''
+class A {
+  foo(int p) => 0;
+}
+class B {
+  foo([int p]) => 0;
+}
+mixin M on A, B {
+  foo(p) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'M').parameters[0];
+    assertElementTypeString(p.type, 'int');
+  }
+
+  test_method_parameter_single_generic() async {
+    addTestFile('''
+class A<E> {
+  foo(E p) => 0;
+}
+mixin M<T> on A<T> {
+  foo(p) => 0;
+}
+''');
+    await resolveTestFile();
+
+    var p = findElement.method('foo', of: 'M').parameters[0];
+    assertElementTypeString(p.type, 'T');
+  }
+
+  test_method_return_multiple_different() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B {
+  double foo() => 0.0;
+}
+mixin M on A, B {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeDynamic(foo.returnType);
+  }
+
+  test_method_return_multiple_different_generic() async {
+    addTestFile('''
+class A<E> {
+  E foo() => null;
+}
+class B<E> {
+  E foo() => null;
+}
+mixin M on A<int>, B<double> {
+  foo() => null;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeDynamic(foo.returnType);
+  }
+
+  test_method_return_multiple_different_void() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B {
+  void foo() => 0;
+}
+mixin M on A, B {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeDynamic(foo.returnType);
+  }
+
+  test_method_return_multiple_dynamic() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B {
+  foo() => 0;
+}
+mixin M on A, B {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeDynamic(foo.returnType);
+  }
+
+  test_method_return_multiple_same_generic() async {
+    addTestFile('''
+class A<E> {
+  E foo() => 0;
+}
+class B<E> {
+  E foo() => 0;
+}
+mixin M<T> on A<T>, B<T> {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeString(foo.returnType, 'T');
+  }
+
+  test_method_return_multiple_same_nonVoid() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+class B {
+  int foo() => 0;
+}
+mixin M on A, B {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeString(foo.returnType, 'int');
+  }
+
+  test_method_return_multiple_same_void() async {
+    addTestFile('''
+class A {
+  void foo() {};
+}
+class B {
+  void foo() {};
+}
+mixin M on A, B {
+  foo() {};
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeString(foo.returnType, 'void');
+  }
+
+  test_method_return_single() async {
+    addTestFile('''
+class A {
+  int foo() => 0;
+}
+mixin M on A {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeString(foo.returnType, 'int');
+  }
+
+  test_method_return_single_generic() async {
+    addTestFile('''
+class A<E> {
+  E foo() => 0;
+}
+mixin M<T> on A<T> {
+  foo() => 0;
+}
+''');
+    await resolveTestFile();
+
+    var foo = findElement.method('foo', of: 'M');
+    assertElementTypeString(foo.returnType, 'T');
+  }
+}
+
+@reflectiveTest
+class InstanceMemberInferenceMixinTaskResolutionTest extends TaskResolutionTest
+    with InstanceMemberInferenceMixinMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/resolution.dart b/pkg/analyzer/test/src/dart/resolution/resolution.dart
index 69c1580..e01671b 100644
--- a/pkg/analyzer/test/src/dart/resolution/resolution.dart
+++ b/pkg/analyzer/test/src/dart/resolution/resolution.dart
@@ -79,6 +79,10 @@
     expect(type, expected);
   }
 
+  void assertElementTypeDynamic(DartType type) {
+    expect(type, isDynamicType);
+  }
+
   void assertElementTypes(List<DartType> types, List<DartType> expected,
       {bool ordered = false}) {
     if (ordered) {
@@ -88,6 +92,10 @@
     }
   }
 
+  void assertElementTypeString(DartType type, String expected) {
+    expect(type.toString(), expected);
+  }
+
   void assertEnclosingElement(Element element, Element expectedEnclosing) {
     expect(element.enclosingElement, expectedEnclosing);
   }
diff --git a/pkg/analyzer/test/src/dart/resolution/test_all.dart b/pkg/analyzer/test/src/dart/resolution/test_all.dart
index b2dee84..d93d42c 100644
--- a/pkg/analyzer/test/src/dart/resolution/test_all.dart
+++ b/pkg/analyzer/test/src/dart/resolution/test_all.dart
@@ -10,6 +10,10 @@
 import 'for_in_test.dart' as for_in_test;
 import 'import_prefix_test.dart' as import_prefix_test;
 import 'instance_creation_test.dart' as instance_creation_test;
+import 'instance_member_inference_class_test.dart'
+    as instance_member_inference_class_test;
+import 'instance_member_inference_mixin_test.dart'
+    as instance_member_inference_mixin_test;
 import 'mixin_test.dart' as mixin_test;
 
 main() {
@@ -20,6 +24,8 @@
     for_in_test.main();
     import_prefix_test.main();
     instance_creation_test.main();
+    instance_member_inference_class_test.main();
+    instance_member_inference_mixin_test.main();
     mixin_test.main();
   }, name: 'resolution');
 }
diff --git a/pkg/analyzer/test/src/task/strong_mode_driver_test.dart b/pkg/analyzer/test/src/task/strong_mode_driver_test.dart
deleted file mode 100644
index e459d9e..0000000
--- a/pkg/analyzer/test/src/task/strong_mode_driver_test.dart
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) 2017, 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.
-
-import 'package:test_reflective_loader/test_reflective_loader.dart';
-
-import 'strong_mode_test.dart';
-
-main() {
-  defineReflectiveSuite(() {
-    defineReflectiveTests(InstanceMemberInferrerTest_Driver);
-  });
-}
-
-@reflectiveTest
-class InstanceMemberInferrerTest_Driver extends InstanceMemberInferrerTest {
-  @override
-  bool get enableNewAnalysisDriver => true;
-}
diff --git a/pkg/analyzer/test/src/task/strong_mode_test.dart b/pkg/analyzer/test/src/task/strong_mode_test.dart
index b0cec78..cbf2625 100644
--- a/pkg/analyzer/test/src/task/strong_mode_test.dart
+++ b/pkg/analyzer/test/src/task/strong_mode_test.dart
@@ -5,9 +5,6 @@
 import 'dart:async';
 
 import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
-import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/strong_mode.dart';
 import 'package:test/test.dart';
@@ -17,438 +14,12 @@
 
 main() {
   defineReflectiveSuite(() {
-    defineReflectiveTests(InstanceMemberInferrerTest);
     defineReflectiveTests(SetFieldTypeTest);
     defineReflectiveTests(VariableGathererTest);
   });
 }
 
 @reflectiveTest
-class InstanceMemberInferrerTest extends ResolverTestCase {
-  InstanceMemberInferrer createInferrer(LibraryElement library) {
-    AnalysisContext context = library.context;
-    var inheritanceManager = new InheritanceManager(library);
-    return new InstanceMemberInferrer(
-        context.typeProvider, (_) => inheritanceManager,
-        typeSystem: context.typeSystem);
-  }
-
-  /**
-   * Add a source with the given [content] and return the result of resolving
-   * the source.
-   */
-  Future<CompilationUnitElement> resolve(String content) async {
-    Source source = addNamedSource('/test.dart', content);
-    if (enableNewAnalysisDriver) {
-      var analysisResult = await computeAnalysisResult(source);
-      return analysisResult.unit.declaredElement;
-    } else {
-      return analysisContext
-          .resolveCompilationUnit2(source, source)
-          .declaredElement;
-    }
-  }
-
-  test_inferCompilationUnit_invalid_inheritanceCycle() async {
-    CompilationUnitElement unit = await resolve('''
-class A extends C {}
-class B extends A {}
-class C extends B {}
-''');
-    _runInferrer(unit);
-  }
-
-  test_inferCompilationUnit_method_parameter_multiple_different() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  $methodName(int p) => 0;
-}
-class B {
-  $methodName(double p) => 0;
-}
-class C implements A, B {
-  $methodName(p) => 0;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    ParameterElement parameterC = methodC.parameters[0];
-    expect(parameterC.type.isDynamic, isTrue);
-
-    _runInferrer(unit);
-
-    expect(parameterC.type.isDynamic, isTrue);
-  }
-
-  test_inferCompilationUnit_method_parameter_multiple_named_different() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  $methodName({int p}) => 0;
-}
-class B {
-  $methodName({int q}) => 0;
-}
-class C implements A, B {
-  $methodName({p}) => 0;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    ParameterElement parameterC = methodC.parameters[0];
-    expect(parameterC.type.isDynamic, isTrue);
-
-    _runInferrer(unit);
-
-    expect(parameterC.type.isDynamic, isTrue);
-  }
-
-  test_inferCompilationUnit_method_parameter_multiple_named_same() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  $methodName({int p}) => 0;
-}
-class B {
-  $methodName({int p}) => 0;
-}
-class C implements A, B {
-  $methodName({p}) => 0;
-}
-''');
-    ClassElement classA = unit.getType('A');
-    MethodElement methodA = classA.getMethod(methodName);
-    ParameterElement parameterA = methodA.parameters[0];
-    DartType expectedType = parameterA.type;
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    ParameterElement parameterC = methodC.parameters[0];
-    if (previewDart2) {
-      expect(parameterC.type.isDynamic, isFalse);
-    } else {
-      expect(parameterC.type.isDynamic, isTrue);
-    }
-
-    _runInferrer(unit);
-
-    expect(parameterC.type, expectedType);
-  }
-
-  test_inferCompilationUnit_method_parameter_multiple_namedAndRequired() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  $methodName({int p}) => 0;
-}
-class B {
-  $methodName(int p) => 0;
-}
-class C implements A, B {
-  $methodName(p) => 0;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    ParameterElement parameterC = methodC.parameters[0];
-    expect(parameterC.type.isDynamic, isTrue);
-
-    _runInferrer(unit);
-
-    expect(parameterC.type.isDynamic, isTrue);
-  }
-
-  test_inferCompilationUnit_method_parameter_multiple_optionalAndRequired() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  $methodName(int p) => 0;
-}
-class B {
-  $methodName([int p]) => 0;
-}
-class C implements A, B {
-  $methodName(p) => 0;
-}
-''');
-    ClassElement classA = unit.getType('A');
-    MethodElement methodA = classA.getMethod(methodName);
-    ParameterElement parameterA = methodA.parameters[0];
-    DartType expectedType = parameterA.type;
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    ParameterElement parameterC = methodC.parameters[0];
-    if (previewDart2) {
-      expect(parameterC.type.isDynamic, isFalse);
-    } else {
-      expect(parameterC.type.isDynamic, isTrue);
-    }
-
-    _runInferrer(unit);
-
-    expect(parameterC.type, expectedType);
-  }
-
-  test_inferCompilationUnit_method_parameter_single_generic() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A<E> {
-  $methodName(E p) => 0;
-}
-class C<E> implements A<E> {
-  $methodName(p) => 0;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    DartType typeCE = classC.typeParameters[0].type;
-    MethodElement methodC = classC.getMethod(methodName);
-    ParameterElement parameterC = methodC.parameters[0];
-    if (previewDart2) {
-      expect(parameterC.type.isDynamic, isFalse);
-    } else {
-      expect(parameterC.type.isDynamic, isTrue);
-    }
-    expect(methodC.type.typeArguments, [typeCE]);
-
-    _runInferrer(unit);
-
-    expect(parameterC.type, classC.typeParameters[0].type);
-    expect(methodC.type.typeArguments, [typeCE],
-        reason: 'function type should still have type arguments');
-  }
-
-  test_inferCompilationUnit_method_return_multiple_different() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  int $methodName() => 0;
-}
-class B {
-  double $methodName() => 0.0;
-}
-class C implements A, B {
-  $methodName() => 0;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    expect(methodC.returnType.isDynamic, isTrue);
-
-    _runInferrer(unit);
-
-    expect(methodC.returnType.isDynamic, isTrue);
-  }
-
-  test_inferCompilationUnit_method_return_multiple_different_generic() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A<E> {
-  E $methodName() => null;
-}
-class B<E> {
-  E $methodName() => null;
-}
-class C implements A<int>, B<double> {
-  $methodName() => null;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    expect(methodC.returnType.isDynamic, isTrue);
-
-    _runInferrer(unit);
-
-    expect(methodC.returnType.isDynamic, isTrue);
-  }
-
-  test_inferCompilationUnit_method_return_multiple_dynamic() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  int $methodName() => 0;
-}
-class B {
-  $methodName() => 0;
-}
-class C implements A, B {
-  $methodName() => 0;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    expect(methodC.returnType.isDynamic, isTrue);
-
-    _runInferrer(unit);
-
-    expect(methodC.returnType.isDynamic, isTrue);
-  }
-
-  test_inferCompilationUnit_method_return_multiple_same_generic() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A<E> {
-  E $methodName() => 0;
-}
-class B<E> {
-  E $methodName() => 0;
-}
-class C<E> implements A<E>, B<E> {
-  $methodName() => 0;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    if (previewDart2) {
-      expect(methodC.returnType.isDynamic, isFalse);
-    } else {
-      expect(methodC.returnType.isDynamic, isTrue);
-    }
-
-    _runInferrer(unit);
-
-    expect(methodC.returnType, classC.typeParameters[0].type);
-  }
-
-  test_inferCompilationUnit_method_return_multiple_same_nonVoid() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  int $methodName() => 0;
-}
-class B {
-  int $methodName() => 0;
-}
-class C implements A, B {
-  $methodName() => 0;
-}
-''');
-    ClassElement classA = unit.getType('A');
-    MethodElement methodA = classA.getMethod(methodName);
-    DartType expectedType = methodA.returnType;
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    if (previewDart2) {
-      expect(methodC.returnType.isDynamic, isFalse);
-    } else {
-      expect(methodC.returnType.isDynamic, isTrue);
-    }
-
-    _runInferrer(unit);
-
-    expect(methodC.returnType, expectedType);
-  }
-
-  test_inferCompilationUnit_method_return_multiple_same_void() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  void $methodName() {};
-}
-class B {
-  void $methodName() {};
-}
-class C implements A, B {
-  $methodName() {};
-}
-''');
-    ClassElement classA = unit.getType('A');
-    MethodElement methodA = classA.getMethod(methodName);
-    DartType expectedType = methodA.returnType;
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    if (previewDart2) {
-      expect(methodC.returnType.isDynamic, isFalse);
-    } else {
-      expect(methodC.returnType.isDynamic, isTrue);
-    }
-
-    _runInferrer(unit);
-
-    expect(methodC.returnType, expectedType);
-  }
-
-  test_inferCompilationUnit_method_return_multiple_void() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  int $methodName() => 0;
-}
-class B {
-  void $methodName() => 0;
-}
-class C implements A, B {
-  $methodName() => 0;
-}
-''');
-    ClassElement classC = unit.getType('C');
-    MethodElement methodC = classC.getMethod(methodName);
-    expect(methodC.returnType.isDynamic, isTrue);
-
-    _runInferrer(unit);
-
-    expect(methodC.returnType.isDynamic, isTrue);
-  }
-
-  test_inferCompilationUnit_method_return_single() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A {
-  int $methodName() => 0;
-}
-class B extends A {
-  $methodName() => 0;
-}
-''');
-    ClassElement classA = unit.getType('A');
-    MethodElement methodA = classA.getMethod(methodName);
-    ClassElement classB = unit.getType('B');
-    MethodElement methodB = classB.getMethod(methodName);
-    if (previewDart2) {
-      expect(methodB.returnType.isDynamic, isFalse);
-    } else {
-      expect(methodB.returnType.isDynamic, isTrue);
-    }
-
-    _runInferrer(unit);
-
-    expect(methodB.returnType, methodA.returnType);
-  }
-
-  test_inferCompilationUnit_method_return_single_generic() async {
-    String methodName = 'm';
-    CompilationUnitElement unit = await resolve('''
-class A<E> {
-  E $methodName() => 0;
-}
-class B<E> extends A<E> {
-  $methodName() => 0;
-}
-''');
-    ClassElement classB = unit.getType('B');
-    DartType typeBE = classB.typeParameters[0].type;
-    MethodElement methodB = classB.getMethod(methodName);
-    if (previewDart2) {
-      expect(methodB.returnType.isDynamic, isFalse);
-    } else {
-      expect(methodB.returnType.isDynamic, isTrue);
-    }
-    expect(methodB.type.typeArguments, [typeBE]);
-
-    _runInferrer(unit);
-
-    expect(methodB.returnType, classB.typeParameters[0].type);
-    expect(methodB.type.typeArguments, [typeBE],
-        reason: 'function type should still have type arguments');
-  }
-
-  InstanceMemberInferrer _runInferrer(CompilationUnitElement unit) {
-    InstanceMemberInferrer inferrer = createInferrer(unit.library);
-    inferrer.inferCompilationUnit(unit);
-    return inferrer;
-  }
-}
-
-@reflectiveTest
 class SetFieldTypeTest extends ResolverTestCase {
   test_setter_withoutParameter() async {
     Source source = addSource('''
diff --git a/pkg/analyzer/test/src/task/test_all.dart b/pkg/analyzer/test/src/task/test_all.dart
index 92e46d2..8d02ae5 100644
--- a/pkg/analyzer/test/src/task/test_all.dart
+++ b/pkg/analyzer/test/src/task/test_all.dart
@@ -18,7 +18,6 @@
 import 'options_test.dart' as options_test;
 import 'options_work_manager_test.dart' as options_work_manager_test;
 import 'strong/test_all.dart' as strong_mode_test_all;
-import 'strong_mode_driver_test.dart' as strong_mode_driver_test;
 import 'strong_mode_test.dart' as strong_mode_test;
 import 'yaml_test.dart' as yaml_test;
 
@@ -37,7 +36,6 @@
     options_test.main();
     options_work_manager_test.main();
     strong_mode_test_all.main();
-    strong_mode_driver_test.main();
     strong_mode_test.main();
     yaml_test.main();
   }, name: 'task');