diff --git a/README.md b/README.md
index 09b6878..5b70df8 100644
--- a/README.md
+++ b/README.md
@@ -65,7 +65,7 @@
 
 // We can calculate a response at call time.
 var responses = ["Purr", "Meow"];
-when(cat.sound()).thenAnswer((_) => responses.removeAt(0));
+when(cat.sound()).thenAnswer(() => responses.removeAt(0));
 expect(cat.sound(), "Purr");
 expect(cat.sound(), "Meow");
 ```
diff --git a/bin/codegen.dart b/bin/codegen.dart
new file mode 100644
index 0000000..f3ec2b5
--- /dev/null
+++ b/bin/codegen.dart
@@ -0,0 +1,19 @@
+// Copyright 2019 Dart Mockito authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import 'package:mockito/src/builder.dart';
+
+import 'package:build/build.dart';
+
+Builder buildMocks(BuilderOptions options) => MockBuilder();
diff --git a/build.yaml b/build.yaml
new file mode 100644
index 0000000..755c286
--- /dev/null
+++ b/build.yaml
@@ -0,0 +1,6 @@
+builders:
+  mockBuilder:
+    import: "package:mockito/src/builder.dart"
+    builder_factories: ["buildMocks"]
+    build_extensions: {".dart": [".mocks.dart"]}
+    build_to: source
diff --git a/example/example.dart b/example/example.dart
index 3a708b5..9742c3a 100644
--- a/example/example.dart
+++ b/example/example.dart
@@ -5,9 +5,9 @@
 
 // Real class
 class Cat {
-  String sound() => 'Meow';
+  String sound() => "Meow";
   bool eatFood(String food, {bool hungry}) => true;
-  Future<void> chew() async => print('Chewing...');
+  Future<void> chew() async => print("Chewing...");
   int walk(List<String> places) => 7;
   void sleep() {}
   void hunt(String place, String prey) {}
@@ -42,20 +42,20 @@
     verify(cat.sound());
   });
 
-  test('How about some stubbing?', () {
+  test("How about some stubbing?", () {
     // Unstubbed methods return null.
     expect(cat.sound(), null);
 
     // Stub a method before interacting with it.
-    when(cat.sound()).thenReturn('Purr');
-    expect(cat.sound(), 'Purr');
+    when(cat.sound()).thenReturn("Purr");
+    expect(cat.sound(), "Purr");
 
     // You can call it again.
-    expect(cat.sound(), 'Purr');
+    expect(cat.sound(), "Purr");
 
     // Let's change the stub.
-    when(cat.sound()).thenReturn('Meow');
-    expect(cat.sound(), 'Meow');
+    when(cat.sound()).thenReturn("Meow");
+    expect(cat.sound(), "Meow");
 
     // You can stub getters.
     when(cat.lives).thenReturn(9);
@@ -66,48 +66,48 @@
     expect(() => cat.lives, throwsRangeError);
 
     // We can calculate a response at call time.
-    var responses = ['Purr', 'Meow'];
+    var responses = ["Purr", "Meow"];
     when(cat.sound()).thenAnswer((_) => responses.removeAt(0));
-    expect(cat.sound(), 'Purr');
-    expect(cat.sound(), 'Meow');
+    expect(cat.sound(), "Purr");
+    expect(cat.sound(), "Meow");
   });
 
-  test('Argument matchers', () {
+  test("Argument matchers", () {
     // You can use plain arguments themselves
-    when(cat.eatFood('fish')).thenReturn(true);
+    when(cat.eatFood("fish")).thenReturn(true);
 
     // ... including collections
-    when(cat.walk(['roof', 'tree'])).thenReturn(2);
+    when(cat.walk(["roof", "tree"])).thenReturn(2);
 
     // ... or matchers
-    when(cat.eatFood(argThat(startsWith('dry')))).thenReturn(false);
+    when(cat.eatFood(argThat(startsWith("dry")))).thenReturn(false);
 
     // ... or mix aguments with matchers
-    when(cat.eatFood(argThat(startsWith('dry')), hungry: true))
+    when(cat.eatFood(argThat(startsWith("dry")), hungry: true))
         .thenReturn(true);
-    expect(cat.eatFood('fish'), isTrue);
-    expect(cat.walk(['roof', 'tree']), equals(2));
-    expect(cat.eatFood('dry food'), isFalse);
-    expect(cat.eatFood('dry food', hungry: true), isTrue);
+    expect(cat.eatFood("fish"), isTrue);
+    expect(cat.walk(["roof", "tree"]), equals(2));
+    expect(cat.eatFood("dry food"), isFalse);
+    expect(cat.eatFood("dry food", hungry: true), isTrue);
 
     // You can also verify using an argument matcher.
-    verify(cat.eatFood('fish'));
-    verify(cat.walk(['roof', 'tree']));
-    verify(cat.eatFood(argThat(contains('food'))));
+    verify(cat.eatFood("fish"));
+    verify(cat.walk(["roof", "tree"]));
+    verify(cat.eatFood(argThat(contains("food"))));
 
     // You can verify setters.
     cat.lives = 9;
     verify(cat.lives = 9);
 
-    cat.hunt('backyard', null);
-    verify(cat.hunt('backyard', null)); // OK: no arg matchers.
+    cat.hunt("backyard", null);
+    verify(cat.hunt("backyard", null)); // OK: no arg matchers.
 
-    cat.hunt('backyard', null);
-    verify(cat.hunt(argThat(contains('yard')),
+    cat.hunt("backyard", null);
+    verify(cat.hunt(argThat(contains("yard")),
         argThat(isNull))); // OK: null is wrapped in an arg matcher.
   });
 
-  test('Named arguments', () {
+  test("Named arguments", () {
     // GOOD: argument matchers include their names.
     when(cat.eatFood(any, hungry: anyNamed('hungry'))).thenReturn(true);
     when(cat.eatFood(any, hungry: argThat(isNotNull, named: 'hungry')))
@@ -117,7 +117,7 @@
         .thenReturn(true);
   });
 
-  test('Verifying exact number of invocations / at least x / never', () {
+  test("Verifying exact number of invocations / at least x / never", () {
     cat.sound();
     cat.sound();
     // Exact number of invocations
@@ -133,41 +133,41 @@
     verifyNever(cat.eatFood(any));
   });
 
-  test('Verification in order', () {
-    cat.eatFood('Milk');
+  test("Verification in order", () {
+    cat.eatFood("Milk");
     cat.sound();
-    cat.eatFood('Fish');
-    verifyInOrder([cat.eatFood('Milk'), cat.sound(), cat.eatFood('Fish')]);
+    cat.eatFood("Fish");
+    verifyInOrder([cat.eatFood("Milk"), cat.sound(), cat.eatFood("Fish")]);
   });
 
-  test('Making sure interaction(s) never happened on mock', () {
+  test("Making sure interaction(s) never happened on mock", () {
     verifyZeroInteractions(cat);
   });
 
-  test('Finding redundant invocations', () {
+  test("Finding redundant invocations", () {
     cat.sound();
     verify(cat.sound());
     verifyNoMoreInteractions(cat);
   });
 
-  test('Capturing arguments for further assertions', () {
+  test("Capturing arguments for further assertions", () {
     // Simple capture:
-    cat.eatFood('Fish');
-    expect(verify(cat.eatFood(captureAny)).captured.single, 'Fish');
+    cat.eatFood("Fish");
+    expect(verify(cat.eatFood(captureAny)).captured.single, "Fish");
 
     // Capture multiple calls:
-    cat.eatFood('Milk');
-    cat.eatFood('Fish');
-    expect(verify(cat.eatFood(captureAny)).captured, ['Milk', 'Fish']);
+    cat.eatFood("Milk");
+    cat.eatFood("Fish");
+    expect(verify(cat.eatFood(captureAny)).captured, ["Milk", "Fish"]);
 
     // Conditional capture:
-    cat.eatFood('Milk');
-    cat.eatFood('Fish');
+    cat.eatFood("Milk");
+    cat.eatFood("Fish");
     expect(
-        verify(cat.eatFood(captureThat(startsWith('F')))).captured, ['Fish']);
+        verify(cat.eatFood(captureThat(startsWith("F")))).captured, ["Fish"]);
   });
 
-  test('Waiting for an interaction', () async {
+  test("Waiting for an interaction", () async {
     Future<void> chewHelper(Cat cat) {
       return cat.chew();
     }
@@ -177,15 +177,15 @@
     await untilCalled(cat.chew()); // This completes when cat.chew() is called.
 
     // Waiting for a call that has already happened.
-    cat.eatFood('Fish');
+    cat.eatFood("Fish");
     await untilCalled(cat.eatFood(any)); // This completes immediately.
   });
 
-  test('Fake class', () {
+  test("Fake class", () {
     // Create a new fake Cat at runtime.
     var cat = FakeCat();
 
-    cat.eatFood('Milk'); // Prints 'Fake eat Milk'.
+    cat.eatFood("Milk"); // Prints 'Fake eat Milk'.
     expect(() => cat.sleep(), throwsUnimplementedError);
   });
 }
diff --git a/example/iss/iss.dart b/example/iss/iss.dart
index eef8df4..e932fd9 100644
--- a/example/iss/iss.dart
+++ b/example/iss/iss.dart
@@ -31,7 +31,9 @@
 
   /// Returns the current GPS position in [latitude, longitude] format.
   Future update() async {
-    _ongoingRequest ??= _doUpdate();
+    if (_ongoingRequest == null) {
+      _ongoingRequest = _doUpdate();
+    }
     await _ongoingRequest;
     _ongoingRequest = null;
   }
@@ -39,7 +41,7 @@
   Future _doUpdate() async {
     // Returns the point on the earth directly under the space station
     // at this moment.
-    var rs = await client.get('http://api.open-notify.org/iss-now.json');
+    Response rs = await client.get('http://api.open-notify.org/iss-now.json');
     var data = jsonDecode(rs.body);
     var latitude = double.parse(data['iss_position']['latitude'] as String);
     var longitude = double.parse(data['iss_position']['longitude'] as String);
@@ -58,7 +60,7 @@
   // The ISS is defined to be visible if the distance from the observer to
   // the point on the earth directly under the space station is less than 80km.
   bool get isVisible {
-    var distance = sphericalDistanceKm(locator.currentPosition, observer);
+    double distance = sphericalDistanceKm(locator.currentPosition, observer);
     return distance < 80.0;
   }
 }
diff --git a/example/iss/iss_test.dart b/example/iss/iss_test.dart
index dc4f3cd..3aa2a62 100644
--- a/example/iss/iss_test.dart
+++ b/example/iss/iss_test.dart
@@ -27,18 +27,18 @@
   // verify the calculated distance between them.
   group('Spherical distance', () {
     test('London - Paris', () {
-      var london = Point(51.5073, -0.1277);
-      var paris = Point(48.8566, 2.3522);
-      var d = sphericalDistanceKm(london, paris);
+      Point<double> london = Point(51.5073, -0.1277);
+      Point<double> paris = Point(48.8566, 2.3522);
+      double d = sphericalDistanceKm(london, paris);
       // London should be approximately 343.5km
       // (+/- 0.1km) from Paris.
       expect(d, closeTo(343.5, 0.1));
     });
 
     test('San Francisco - Mountain View', () {
-      var sf = Point(37.783333, -122.416667);
-      var mtv = Point(37.389444, -122.081944);
-      var d = sphericalDistanceKm(sf, mtv);
+      Point<double> sf = Point(37.783333, -122.416667);
+      Point<double> mtv = Point(37.389444, -122.081944);
+      double d = sphericalDistanceKm(sf, mtv);
       // San Francisco should be approximately 52.8km
       // (+/- 0.1km) from Mountain View.
       expect(d, closeTo(52.8, 0.1));
@@ -52,8 +52,8 @@
   // second predefined location. This test runs asynchronously.
   group('ISS spotter', () {
     test('ISS visible', () async {
-      var sf = Point(37.783333, -122.416667);
-      var mtv = Point(37.389444, -122.081944);
+      Point<double> sf = Point(37.783333, -122.416667);
+      Point<double> mtv = Point(37.389444, -122.081944);
       IssLocator locator = MockIssLocator();
       // Mountain View should be visible from San Francisco.
       when(locator.currentPosition).thenReturn(sf);
@@ -63,8 +63,8 @@
     });
 
     test('ISS not visible', () async {
-      var london = Point(51.5073, -0.1277);
-      var mtv = Point(37.389444, -122.081944);
+      Point<double> london = Point(51.5073, -0.1277);
+      Point<double> mtv = Point(37.389444, -122.081944);
       IssLocator locator = MockIssLocator();
       // London should not be visible from Mountain View.
       when(locator.currentPosition).thenReturn(london);
diff --git a/lib/annotations.dart b/lib/annotations.dart
new file mode 100644
index 0000000..bf1f5da
--- /dev/null
+++ b/lib/annotations.dart
@@ -0,0 +1,19 @@
+// Copyright 2019 Dart Mockito authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+class GenerateMocks {
+  final List<Type> classes;
+
+  const GenerateMocks(this.classes);
+}
diff --git a/lib/src/builder.dart b/lib/src/builder.dart
new file mode 100644
index 0000000..16bd59f
--- /dev/null
+++ b/lib/src/builder.dart
@@ -0,0 +1,228 @@
+// Copyright 2019 Dart Mockito authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:build/build.dart';
+import 'package:code_builder/code_builder.dart';
+import 'package:dart_style/dart_style.dart';
+
+/// For a source Dart library, generate the mocks referenced therein.
+///
+/// Given an input library, 'foo.dart', this builder will search the top-level
+/// elements for an annotation, `@GenerateMocks`, from the mockito package. For
+/// example:
+///
+/// ```dart
+/// @GenerateMocks[Foo]
+/// void main() {}
+/// ```
+///
+/// If this builder finds any classes to mock (for example, `Foo`, above), it
+/// will produce a "'.mocks.dart' file with such mocks. In this example,
+/// 'foo.mocks.dart' will be created.
+class MockBuilder implements Builder {
+  @override
+  Future build(BuildStep buildStep) async {
+    final entryLib = await buildStep.inputLibrary;
+    final resolver = buildStep.resolver;
+
+    final mockLibrary = buildStep.inputId.changeExtension('.mocks.dart');
+
+    final mockClasses = <Class>[];
+
+    for (final element in entryLib.topLevelElements) {
+      final annotation = element.metadata.firstWhere(
+          (annotation) =>
+              annotation.element is ConstructorElement &&
+              annotation.element.enclosingElement.name == 'GenerateMocks',
+          orElse: () => null);
+      if (annotation == null) continue;
+      final generateMocksValue = annotation.computeConstantValue();
+      // TODO(srawlins): handle `generateMocksValue == null`?
+      final classesToMock = generateMocksValue.getField('classes');
+      if (classesToMock.isNull)
+        // TODO(srawlins): Log severe instead? How? How to test?
+        throw StateError(
+            'Unresolved "classes" argument for GenerateMocks has errors: '
+            '"${generateMocksValue}');
+      for (final classToMock in classesToMock.toListValue()) {
+        final dartTypeToMock = classToMock.toTypeValue();
+        // TODO(srawlins): Import the library which declares [dartTypeToMock].
+        // TODO(srawlins): Import all supporting libraries, used in type
+        // signatures.
+        _buildCodeForClass(dartTypeToMock, mockClasses);
+      }
+    }
+
+    if (mockClasses.isEmpty) {
+      // Nothing to mock here!
+      return;
+    }
+
+    final emitter = DartEmitter();
+    final mockLibraryContent = DartFormatter()
+        .format(mockClasses.map((c) => c.accept(emitter)).join('\n'));
+
+    await buildStep.writeAsString(mockLibrary, mockLibraryContent);
+  }
+
+  void _buildCodeForClass(final DartType dartType, List<Class> mockClasses) {
+    final elementToMock = dartType.element;
+    // TODO(srawlins): Log/throw here.
+    if (elementToMock is! ClassElement) return;
+    final classToMock = elementToMock as ClassElement;
+    final className = dartType.displayName;
+
+    // TODO(srawlins): Add a dartdoc to the Mock class.
+    final mockClass = Class((cBuilder) {
+      cBuilder
+        ..name = 'Mock$className'
+        ..extend = refer('Mock')
+        ..implements.add(refer(className))
+        ..docs.add('/// A class which mocks [$className].')
+        ..docs.add('///')
+        ..docs.add('/// See the documentation for Mockito\'s code generation '
+            'for more information.');
+      for (final field in classToMock.fields) {
+        if (field.isPrivate || field.isStatic) {
+          continue;
+        }
+        // Handle getters when we handle non-nullable return types.
+        final setter = field.setter;
+        if (setter != null) {
+          cBuilder.methods.add(
+              Method((mBuilder) => _buildOverridingSetter(mBuilder, setter)));
+        }
+      }
+      for (final method in classToMock.methods) {
+        if (method.parameters.isEmpty || method.isPrivate || method.isStatic) {
+          continue;
+        }
+        cBuilder.methods.add(
+            Method((mBuilder) => _buildOverridingMethod(mBuilder, method)));
+      }
+    });
+
+    mockClasses.add(mockClass);
+  }
+
+  /// Build a method which overrides [method], with all non-nullable
+  /// parameter types widened to be nullable.
+  ///
+  /// This new method just calls `super.noSuchMethod`, optionally passing a
+  /// return value for methods with a non-nullable return type.
+  // TODO(srawlins): This method does no widening yet. Widen parameters. Include
+  // tests for typedefs, old-style function parameters, and function types.
+  // TODO(srawlins): This method declares no specific non-null return values
+  // yet.
+  void _buildOverridingMethod(MethodBuilder builder, MethodElement method) {
+    // TODO(srawlins): generator methods like async*, sync*.
+    // TODO(srawlins): abstract methods?
+    builder
+      ..name = method.displayName
+      ..returns = refer(method.returnType.displayName);
+
+    if (method.isAsynchronous) {
+      builder.modifier =
+          method.isGenerator ? MethodModifier.asyncStar : MethodModifier.async;
+    } else if (method.isGenerator) {
+      builder.modifier = MethodModifier.syncStar;
+    }
+
+    // These two variables store the arguments that will be passed to the
+    // [Invocation] built for `noSuchMethod`.
+    final invocationPositionalArgs = <Expression>[];
+    final invocationNamedArgs = <Expression, Expression>{};
+
+    for (final parameter in method.parameters) {
+      if (parameter.isRequiredPositional) {
+        builder.requiredParameters.add(_matchingParameter(parameter));
+        invocationPositionalArgs.add(refer(parameter.displayName));
+      } else if (parameter.isOptionalPositional) {
+        builder.optionalParameters.add(_matchingParameter(parameter));
+        invocationPositionalArgs.add(refer(parameter.displayName));
+      } else if (parameter.isNamed) {
+        builder.optionalParameters.add(_matchingParameter(parameter));
+        invocationNamedArgs[refer('#${parameter.displayName}')] =
+            refer(parameter.displayName);
+      }
+    }
+    // TODO(srawlins): Optionally pass a non-null return value to `noSuchMethod`
+    // which `Mock.noSuchMethod` will simply return, in order to satisfy runtime
+    // type checks.
+    // TODO(srawlins): Handle getter invocations with `Invocation.getter`,
+    // and operators???
+    // TODO(srawlins): Handle generic methods with `Invocation.genericMethod`.
+    final invocation = refer('Invocation').property('method').call([
+      refer('#${method.displayName}'),
+      literalList(invocationPositionalArgs),
+      if (invocationNamedArgs.isNotEmpty) literalMap(invocationNamedArgs),
+    ]);
+    final returnNoSuchMethod =
+        refer('super').property('noSuchMethod').call([invocation]);
+
+    builder.body = returnNoSuchMethod.code;
+  }
+
+  /// Returns a [Parameter] which matches [parameter].
+  Parameter _matchingParameter(ParameterElement parameter) =>
+      Parameter((pBuilder) {
+        pBuilder
+          ..name = parameter.displayName
+          ..type = refer(parameter.type.displayName);
+        if (parameter.isNamed) pBuilder.named = true;
+        if (parameter.defaultValueCode != null) {
+          pBuilder.defaultTo = Code(parameter.defaultValueCode);
+        }
+      });
+
+  /// Build a setter which overrides [setter], widening the single parameter
+  /// type to be nullable if it is non-nullable.
+  ///
+  /// This new setter just calls `super.noSuchMethod`.
+  // TODO(srawlins): This method does no widening yet.
+  void _buildOverridingSetter(
+      MethodBuilder builder, PropertyAccessorElement setter) {
+    builder
+      ..name = setter.displayName
+      ..type = MethodType.setter;
+
+    final invocationPositionalArgs = <Expression>[];
+    // There should only be one required positional parameter. Should we assert
+    // on that? Leave it alone?
+    for (final parameter in setter.parameters) {
+      if (parameter.isRequiredPositional) {
+        builder.requiredParameters.add(Parameter((pBuilder) => pBuilder
+          ..name = parameter.displayName
+          ..type = refer(parameter.type.displayName)));
+        invocationPositionalArgs.add(refer(parameter.displayName));
+      }
+    }
+
+    final invocation = refer('Invocation').property('setter').call([
+      refer('#${setter.displayName}'),
+      literalList(invocationPositionalArgs),
+    ]);
+    final returnNoSuchMethod =
+        refer('super').property('noSuchMethod').call([invocation]);
+
+    builder.body = returnNoSuchMethod.code;
+  }
+
+  @override
+  final buildExtensions = const {
+    '.dart': ['.mocks.dart']
+  };
+}
diff --git a/lib/src/mock.dart b/lib/src/mock.dart
index d83c070..320586e 100644
--- a/lib/src/mock.dart
+++ b/lib/src/mock.dart
@@ -17,7 +17,6 @@
 import 'package:meta/meta.dart';
 import 'package:mockito/src/call_pair.dart';
 import 'package:mockito/src/invocation_matcher.dart';
-// ignore: deprecated_member_use
 import 'package:test_api/test_api.dart';
 // TODO(srawlins): Remove this when we no longer need to check for an
 // incompatiblity between test_api and test.
@@ -38,8 +37,7 @@
 @Deprecated(
     'This function is not a supported function, and may be deleted as early as '
     'Mockito 5.0.0')
-void setDefaultResponse(
-    Mock mock, CallPair<dynamic> Function() defaultResponse) {
+void setDefaultResponse(Mock mock, CallPair<dynamic> defaultResponse()) {
   mock._defaultResponse = defaultResponse;
 }
 
@@ -138,7 +136,7 @@
       const Object().noSuchMethod(invocation);
 
   @override
-  int get hashCode => _givenHashCode ?? 0;
+  int get hashCode => _givenHashCode == null ? 0 : _givenHashCode;
 
   @override
   bool operator ==(other) => (_givenHashCode != null && other is Mock)
@@ -146,7 +144,7 @@
       : identical(this, other);
 
   @override
-  String toString() => _givenName ?? runtimeType.toString();
+  String toString() => _givenName != null ? _givenName : runtimeType.toString();
 
   String _realCallsToString() {
     var stringRepresentations = _realCalls.map((call) => call.toString());
@@ -240,7 +238,7 @@
   factory _InvocationForMatchedArguments(Invocation invocation) {
     if (_storedArgs.isEmpty && _storedNamedArgs.isEmpty) {
       throw StateError(
-          '_InvocationForMatchedArguments called when no ArgMatchers have been saved.');
+          "_InvocationForMatchedArguments called when no ArgMatchers have been saved.");
     }
 
     // Handle named arguments first, so that we can provide useful errors for
@@ -291,7 +289,7 @@
     // Iterate through the stored named args, validate them, and add them to
     // the return map.
     _storedNamedArgs.forEach((name, arg) {
-      var nameSymbol = Symbol(name);
+      Symbol nameSymbol = Symbol(name);
       if (!invocation.namedArguments.containsKey(nameSymbol)) {
         // Clear things out for the next call.
         _storedArgs.clear();
@@ -346,8 +344,8 @@
           'needs to specify the name of the argument it is being used in. For '
           'example: `when(obj.fn(x: anyNamed("x")))`).');
     }
-    var storedIndex = 0;
-    var positionalIndex = 0;
+    int storedIndex = 0;
+    int positionalIndex = 0;
     while (storedIndex < _storedArgs.length &&
         positionalIndex < invocation.positionalArguments.length) {
       var arg = _storedArgs[storedIndex];
@@ -458,7 +456,7 @@
   }
 
   void _captureArguments(Invocation invocation) {
-    var index = 0;
+    int index = 0;
     for (var roleArg in roleInvocation.positionalArguments) {
       var actArg = invocation.positionalArguments[index];
       if (roleArg is ArgMatcher && roleArg._capture) {
@@ -486,7 +484,7 @@
         roleInvocation.namedArguments.length) {
       return false;
     }
-    var index = 0;
+    int index = 0;
     for (var roleArg in roleInvocation.positionalArguments) {
       var actArg = invocation.positionalArguments[index];
       if (!isMatchingArg(roleArg, actArg)) {
@@ -543,7 +541,8 @@
   @override
   String toString() {
     var argString = '';
-    var args = invocation.positionalArguments.map((v) => '$v');
+    var args = invocation.positionalArguments
+        .map((v) => v == null ? "null" : v.toString());
     if (args.any((arg) => arg.contains('\n'))) {
       // As one or more arg contains newlines, put each on its own line, and
       // indent each, for better readability.
@@ -650,18 +649,18 @@
     if (!never && matchingInvocations.isEmpty) {
       var message;
       if (mock._realCalls.isEmpty) {
-        message = 'No matching calls (actually, no calls at all).';
+        message = "No matching calls (actually, no calls at all).";
       } else {
         var otherCalls = mock._realCallsToString();
-        message = 'No matching calls. All calls: $otherCalls';
+        message = "No matching calls. All calls: $otherCalls";
       }
-      fail('$message\n'
-          '(If you called `verify(...).called(0);`, please instead use '
-          '`verifyNever(...);`.)');
+      fail("$message\n"
+          "(If you called `verify(...).called(0);`, please instead use "
+          "`verifyNever(...);`.)");
     }
     if (never && matchingInvocations.isNotEmpty) {
       var calls = mock._realCallsToString();
-      fail('Unexpected calls. All calls: $calls');
+      fail("Unexpected calls. All calls: $calls");
     }
     matchingInvocations.forEach((inv) {
       inv.verified = true;
@@ -874,7 +873,7 @@
       _checkTestApiMismatch();
     }
     expect(callCount, wrapMatcher(matcher),
-        reason: 'Unexpected number of calls');
+        reason: "Unexpected number of calls");
   }
 }
 
@@ -940,12 +939,12 @@
   return <T>(T mock) {
     _verificationInProgress = false;
     if (_verifyCalls.length == 1) {
-      var verifyCall = _verifyCalls.removeLast();
+      _VerifyCall verifyCall = _verifyCalls.removeLast();
       var result = VerificationResult._(verifyCall.matchingInvocations.length);
       verifyCall._checkWith(never);
       return result;
     } else {
-      fail('Used on a non-mockito object');
+      fail("Used on a non-mockito object");
     }
   };
 }
@@ -971,22 +970,23 @@
   _verificationInProgress = true;
   return <T>(List<T> _) {
     _verificationInProgress = false;
-    var dt = DateTime.fromMillisecondsSinceEpoch(0);
+    DateTime dt = DateTime.fromMillisecondsSinceEpoch(0);
     var tmpVerifyCalls = List<_VerifyCall>.from(_verifyCalls);
     _verifyCalls.clear();
-    var matchedCalls = <RealCall>[];
-    for (var verifyCall in tmpVerifyCalls) {
-      var matched = verifyCall._findAfter(dt);
+    List<RealCall> matchedCalls = [];
+    for (_VerifyCall verifyCall in tmpVerifyCalls) {
+      RealCall matched = verifyCall._findAfter(dt);
       if (matched != null) {
         matchedCalls.add(matched);
         dt = matched.timeStamp;
       } else {
-        var mocks = tmpVerifyCalls.map((vc) => vc.mock).toSet();
-        var allInvocations =
+        Set<Mock> mocks =
+            tmpVerifyCalls.map((_VerifyCall vc) => vc.mock).toSet();
+        List<RealCall> allInvocations =
             mocks.expand((m) => m._realCalls).toList(growable: false);
         allInvocations
             .sort((inv1, inv2) => inv1.timeStamp.compareTo(inv2.timeStamp));
-        var otherCalls = '';
+        String otherCalls = "";
         if (allInvocations.isNotEmpty) {
           otherCalls = " All calls: ${allInvocations.join(", ")}";
         }
@@ -1011,7 +1011,7 @@
   if (mock is Mock) {
     var unverified = mock._realCalls.where((inv) => !inv.verified).toList();
     if (unverified.isNotEmpty) {
-      fail('No more calls expected, but following found: ' + unverified.join());
+      fail("No more calls expected, but following found: " + unverified.join());
     }
   } else {
     _throwMockArgumentError('verifyNoMoreInteractions', mock);
@@ -1021,7 +1021,7 @@
 void verifyZeroInteractions(var mock) {
   if (mock is Mock) {
     if (mock._realCalls.isNotEmpty) {
-      fail('No interaction expected, but following found: ' +
+      fail("No interaction expected, but following found: " +
           mock._realCalls.join());
     }
   } else {
@@ -1084,7 +1084,7 @@
 
 /// Print all collected invocations of any mock methods of [mocks].
 void logInvocations(List<Mock> mocks) {
-  var allInvocations =
+  List<RealCall> allInvocations =
       mocks.expand((m) => m._realCalls).toList(growable: false);
   allInvocations.sort((inv1, inv2) => inv1.timeStamp.compareTo(inv2.timeStamp));
   allInvocations.forEach((inv) {
diff --git a/pubspec.yaml b/pubspec.yaml
index 1f438d9..521dd80 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: mockito
-version: 4.1.2-dev
+version: 4.1.1
 
 authors:
   - Dmitriy Fibulwinter <fibulwinter@gmail.com>
@@ -9,10 +9,14 @@
 homepage: https://github.com/dart-lang/mockito
 
 environment:
-  sdk: '>=2.0.0 <3.0.0'
+  sdk: '>=2.3.0 <3.0.0'
 
 dependencies:
+  analyzer: ^0.36.0
+  build: ^1.1.3
+  code_builder: ^3.2.0
   collection: ^1.1.0
+  dart_style: ^1.2.5
   matcher: ^0.12.3
   meta: ^1.0.4
   test_api: ^0.2.1
diff --git a/test/all.dart b/test/all.dart
index ef120e6..0aa5635 100644
--- a/test/all.dart
+++ b/test/all.dart
@@ -15,6 +15,7 @@
 // This file explicitly does _not_ end in `_test.dart`, so that it is not picked
 // up by `pub run test`. It is here for coveralls.
 
+import 'builder_test.dart' as builder_test;
 import 'capture_test.dart' as capture_test;
 import 'invocation_matcher_test.dart' as invocation_matcher_test;
 import 'mockito_test.dart' as mockito_test;
@@ -22,6 +23,7 @@
 import 'verify_test.dart' as verify_test;
 
 void main() {
+  builder_test.main();
   capture_test.main();
   invocation_matcher_test.main();
   mockito_test.main();
diff --git a/test/builder_test.dart b/test/builder_test.dart
new file mode 100644
index 0000000..c2a4224
--- /dev/null
+++ b/test/builder_test.dart
@@ -0,0 +1,266 @@
+// Copyright 2019 Dart Mockito authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import 'package:build/build.dart';
+import 'package:build_test/build_test.dart';
+import 'package:mockito/src/builder.dart';
+import 'package:test/test.dart';
+
+Builder buildMocks(BuilderOptions options) => MockBuilder();
+
+const annotationsAsset = {
+  'mockito|lib/annotations.dart': '''
+class GenerateMocks {
+  final List<Type> classes;
+
+  const GenerateMocks(this.classes);
+}
+'''
+};
+
+const simpleTestAsset = {
+  'foo|test/foo_test.dart': '''
+import 'package:foo/foo.dart';
+import 'package:mockito/annotations.dart';
+@GenerateMocks([Foo])
+void main() {}
+'''
+};
+
+void main() {
+  test(
+      'generates mock for an imported class but does not override private '
+      'or static methods or methods w/ zero parameters', () async {
+    await testBuilder(
+      buildMocks(BuilderOptions({})),
+      {
+        ...annotationsAsset,
+        ...simpleTestAsset,
+        'foo|lib/foo.dart': dedent(r'''
+        class Foo {
+          int a() => 7;
+          int _b(int x) => 8;
+          static int c(int y) => 9;
+        }
+        '''),
+      },
+      outputs: {
+        'foo|test/foo_test.mocks.dart': dedent(r'''
+        /// A class which mocks [Foo].
+        ///
+        /// See the documentation for Mockito's code generation for more information.
+        class MockFoo extends Mock implements Foo {}
+        '''),
+      },
+    );
+  });
+
+  test(
+      'generates mock for an imported class but does not override private '
+      'or static fields', () async {
+    await testBuilder(
+      buildMocks(BuilderOptions({})),
+      {
+        ...annotationsAsset,
+        ...simpleTestAsset,
+        'foo|lib/foo.dart': dedent(r'''
+        class Foo {
+          int _a;
+          static int b;
+        }
+        '''),
+      },
+      outputs: {
+        'foo|test/foo_test.mocks.dart': dedent(r'''
+        /// A class which mocks [Foo].
+        ///
+        /// See the documentation for Mockito's code generation for more information.
+        class MockFoo extends Mock implements Foo {}
+        '''),
+      },
+    );
+  });
+
+  test(
+      'generates mock for an imported class but does not override any '
+      'extension methods', () async {
+    await testBuilder(
+      buildMocks(BuilderOptions({})),
+      {
+        ...annotationsAsset,
+        ...simpleTestAsset,
+        'foo|lib/foo.dart': dedent(r'''
+        extension X on Foo {
+          dynamic x(int m, String n) => n + 1;
+        }
+        class Foo {
+          dynamic a(int m, String n) => n + 1;
+        }
+        '''),
+      },
+      outputs: {
+        'foo|test/foo_test.mocks.dart': dedent(r'''
+        /// A class which mocks [Foo].
+        ///
+        /// See the documentation for Mockito's code generation for more information.
+        class MockFoo extends Mock implements Foo {
+          dynamic a(int m, String n) =>
+              super.noSuchMethod(Invocation.method(#a, [m, n]));
+        }
+        '''),
+      },
+    );
+  });
+
+  test('generates a mock class and overrides methods parameters', () async {
+    await testBuilder(
+      buildMocks(BuilderOptions({})),
+      {
+        ...annotationsAsset,
+        ...simpleTestAsset,
+        'foo|lib/foo.dart': dedent(r'''
+        class Foo {
+          dynamic a(int m, String n) => n + 1;
+          dynamic b(List<int> list) => list.length;
+          void c(String one, [String two, String three = ""]) => print('$one$two$three');
+          void d(String one, {String two, String three = ""}) => print('$one$two$three');
+          Future<void> e(String s) async => print(s);
+          // TODO(srawlins): Figure out async*; doesn't work yet. `isGenerator`
+          // does not appear to be working.
+          // Stream<void> f(String s) async* => print(s);
+          // Iterable<void> g(String s) sync* => print(s);
+        }
+        '''),
+      },
+      outputs: {
+        'foo|test/foo_test.mocks.dart': dedent(r'''
+        /// A class which mocks [Foo].
+        ///
+        /// See the documentation for Mockito's code generation for more information.
+        class MockFoo extends Mock implements Foo {
+          dynamic a(int m, String n) =>
+              super.noSuchMethod(Invocation.method(#a, [m, n]));
+          dynamic b(List<int> list) =>
+              super.noSuchMethod(Invocation.method(#b, [list]));
+          void c(String one, [String two, String three = ""]) =>
+              super.noSuchMethod(Invocation.method(#c, [one, two, three]));
+          void d(String one, {String two, String three = ""}) => super
+              .noSuchMethod(Invocation.method(#d, [one], {#two: two, #three: three}));
+          Future<void> e(String s) async =>
+              super.noSuchMethod(Invocation.method(#e, [s]));
+        }
+        '''),
+      },
+    );
+  });
+
+  test('generates multiple mock classes', () async {
+    await testBuilder(
+      buildMocks(BuilderOptions({})),
+      {
+        ...annotationsAsset,
+        'foo|lib/foo.dart': dedent(r'''
+        class Foo {
+          dynamic a(int m, String n) => n + 1;
+        }
+        class Bar {
+          dynamic b(List<int> list) => list.length;
+        }
+        '''),
+        'foo|test/foo_test.dart': '''
+        import 'package:foo/foo.dart';
+        import 'package:mockito/annotations.dart';
+        @GenerateMocks([Foo, Bar])
+        void main() {}
+        '''
+      },
+      outputs: {
+        'foo|test/foo_test.mocks.dart': dedent(r'''
+        /// A class which mocks [Foo].
+        ///
+        /// See the documentation for Mockito's code generation for more information.
+        class MockFoo extends Mock implements Foo {
+          dynamic a(int m, String n) =>
+              super.noSuchMethod(Invocation.method(#a, [m, n]));
+        }
+
+        /// A class which mocks [Bar].
+        ///
+        /// See the documentation for Mockito's code generation for more information.
+        class MockBar extends Mock implements Bar {
+          dynamic b(List<int> list) =>
+              super.noSuchMethod(Invocation.method(#b, [list]));
+        }
+        '''),
+      },
+    );
+  });
+
+  test('generates a mock class and overrides getters and setters', () async {
+    await testBuilder(
+      buildMocks(BuilderOptions({})),
+      {
+        ...annotationsAsset,
+        ...simpleTestAsset,
+        'foo|lib/foo.dart': dedent(r'''
+        class Foo {
+          int get a => n + 1;
+          int _b;
+          set b(int value) => _b = value;
+        }
+        '''),
+      },
+      outputs: {
+        // TODO(srawlins): The getter will appear when it has a non-nullable
+        // return type.
+        'foo|test/foo_test.mocks.dart': dedent(r'''
+        /// A class which mocks [Foo].
+        ///
+        /// See the documentation for Mockito's code generation for more information.
+        class MockFoo extends Mock implements Foo {
+          set b(int value) => super.noSuchMethod(Invocation.setter(#b, [value]));
+        }
+        '''),
+      },
+    );
+  });
+  test('throws given bad input', () async {
+    expect(
+        () async => await testBuilder(
+              buildMocks(BuilderOptions({})),
+              {
+                ...annotationsAsset,
+                'foo|lib/foo.dart': dedent(r'''
+                class Foo {}
+                '''),
+                'foo|test/foo_test.dart': dedent('''
+                // missing foo.dart import.
+                import 'package:mockito/annotations.dart';
+                @GenerateMocks([Foo])
+                void main() {}
+                '''),
+              },
+            ),
+        throwsStateError);
+  });
+}
+
+/// Dedent [input], so that each line is shifted to the left, so that the first
+/// line is at the 0 column.
+String dedent(String input) {
+  final indentMatch = RegExp(r'^(\s*)').firstMatch(input);
+  final indent = ''.padRight(indentMatch.group(1).length);
+  return input.splitMapJoin('\n',
+      onNonMatch: (s) => s.replaceFirst(RegExp('^$indent'), ''));
+}
diff --git a/test/capture_test.dart b/test/capture_test.dart
index 7c597ba..09da045 100644
--- a/test/capture_test.dart
+++ b/test/capture_test.dart
@@ -22,7 +22,7 @@
   String methodWithNormalArgs(int x) => 'Real';
   String methodWithListArgs(List<int> x) => 'Real';
   String methodWithPositionalArgs(int x, [int y]) => 'Real';
-  String methodWithTwoNamedArgs(int x, {int y, int z}) => 'Real';
+  String methodWithTwoNamedArgs(int x, {int y, int z}) => "Real";
   set setter(String arg) {
     throw StateError('I must be mocked');
   }
diff --git a/test/deprecated_apis/mockito_test.dart b/test/deprecated_apis/mockito_test.dart
index ab9a4e3..95dbcb4 100644
--- a/test/deprecated_apis/mockito_test.dart
+++ b/test/deprecated_apis/mockito_test.dart
@@ -24,18 +24,18 @@
 
 class _RealClass {
   _RealClass innerObj;
-  String methodWithoutArgs() => 'Real';
-  String methodWithNormalArgs(int x) => 'Real';
-  String methodWithListArgs(List<int> x) => 'Real';
-  String methodWithPositionalArgs(int x, [int y]) => 'Real';
-  String methodWithNamedArgs(int x, {int y}) => 'Real';
-  String methodWithTwoNamedArgs(int x, {int y, int z}) => 'Real';
-  String methodWithObjArgs(_RealClass x) => 'Real';
-  Future<String> methodReturningFuture() => Future.value('Real');
-  Stream<String> methodReturningStream() => Stream.fromIterable(['Real']);
-  String get getter => 'Real';
+  String methodWithoutArgs() => "Real";
+  String methodWithNormalArgs(int x) => "Real";
+  String methodWithListArgs(List<int> x) => "Real";
+  String methodWithPositionalArgs(int x, [int y]) => "Real";
+  String methodWithNamedArgs(int x, {int y}) => "Real";
+  String methodWithTwoNamedArgs(int x, {int y, int z}) => "Real";
+  String methodWithObjArgs(_RealClass x) => "Real";
+  Future<String> methodReturningFuture() => Future.value("Real");
+  Stream<String> methodReturningStream() => Stream.fromIterable(["Real"]);
+  String get getter => "Real";
   set setter(String arg) {
-    throw StateError('I must be mocked');
+    throw StateError("I must be mocked");
   }
 }
 
@@ -54,23 +54,23 @@
 
 class _MockedClass extends Mock implements _RealClass {}
 
-void expectFail(String expectedMessage, void Function() expectedToFail) {
+void expectFail(String expectedMessage, dynamic expectedToFail()) {
   try {
     expectedToFail();
-    fail('It was expected to fail!');
+    fail("It was expected to fail!");
   } catch (e) {
     if (!(e is TestFailure)) {
       rethrow;
     } else {
       if (expectedMessage != e.message) {
-        throw TestFailure('Failed, but with wrong message: ${e.message}');
+        throw TestFailure("Failed, but with wrong message: ${e.message}");
       }
     }
   }
 }
 
-String noMatchingCallsFooter = '(If you called `verify(...).called(0);`, '
-    'please instead use `verifyNever(...);`.)';
+String noMatchingCallsFooter = "(If you called `verify(...).called(0);`, "
+    "please instead use `verifyNever(...);`.)";
 
 void main() {
   _MockedClass mock;
@@ -85,67 +85,67 @@
     resetMockitoState();
   });
 
-  group('when()', () {
-    test('should mock method with argument matcher', () {
+  group("when()", () {
+    test("should mock method with argument matcher", () {
       when(mock.methodWithNormalArgs(typed(argThat(greaterThan(100)))))
-          .thenReturn('A lot!');
+          .thenReturn("A lot!");
       expect(mock.methodWithNormalArgs(100), isNull);
-      expect(mock.methodWithNormalArgs(101), equals('A lot!'));
+      expect(mock.methodWithNormalArgs(101), equals("A lot!"));
     });
 
-    test('should mock method with any argument matcher', () {
-      when(mock.methodWithNormalArgs(typed(any))).thenReturn('A lot!');
-      expect(mock.methodWithNormalArgs(100), equals('A lot!'));
-      expect(mock.methodWithNormalArgs(101), equals('A lot!'));
+    test("should mock method with any argument matcher", () {
+      when(mock.methodWithNormalArgs(typed(any))).thenReturn("A lot!");
+      expect(mock.methodWithNormalArgs(100), equals("A lot!"));
+      expect(mock.methodWithNormalArgs(101), equals("A lot!"));
     });
 
-    test('should mock method with any list argument matcher', () {
-      when(mock.methodWithListArgs(typed(any))).thenReturn('A lot!');
-      expect(mock.methodWithListArgs([42]), equals('A lot!'));
-      expect(mock.methodWithListArgs([43]), equals('A lot!'));
+    test("should mock method with any list argument matcher", () {
+      when(mock.methodWithListArgs(typed(any))).thenReturn("A lot!");
+      expect(mock.methodWithListArgs([42]), equals("A lot!"));
+      expect(mock.methodWithListArgs([43]), equals("A lot!"));
     });
 
-    test('should mock method with mix of argument matchers and real things',
+    test("should mock method with mix of argument matchers and real things",
         () {
       when(mock.methodWithPositionalArgs(typed(argThat(greaterThan(100))), 17))
-          .thenReturn('A lot with 17');
+          .thenReturn("A lot with 17");
       expect(mock.methodWithPositionalArgs(100, 17), isNull);
       expect(mock.methodWithPositionalArgs(101, 18), isNull);
-      expect(mock.methodWithPositionalArgs(101, 17), equals('A lot with 17'));
+      expect(mock.methodWithPositionalArgs(101, 17), equals("A lot with 17"));
     });
 
     //no need to mock setter, except if we will have spies later...
-    test('should mock method with thrown result', () {
+    test("should mock method with thrown result", () {
       when(mock.methodWithNormalArgs(typed(any))).thenThrow(StateError('Boo'));
       expect(() => mock.methodWithNormalArgs(42), throwsStateError);
     });
 
-    test('should mock method with calculated result', () {
+    test("should mock method with calculated result", () {
       when(mock.methodWithNormalArgs(typed(any))).thenAnswer(
           (Invocation inv) => inv.positionalArguments[0].toString());
-      expect(mock.methodWithNormalArgs(43), equals('43'));
-      expect(mock.methodWithNormalArgs(42), equals('42'));
+      expect(mock.methodWithNormalArgs(43), equals("43"));
+      expect(mock.methodWithNormalArgs(42), equals("42"));
     });
 
-    test('should mock method with calculated result', () {
+    test("should mock method with calculated result", () {
       when(mock.methodWithNormalArgs(typed(argThat(equals(43)))))
-          .thenReturn('43');
+          .thenReturn("43");
       when(mock.methodWithNormalArgs(typed(argThat(equals(42)))))
-          .thenReturn('42');
-      expect(mock.methodWithNormalArgs(43), equals('43'));
+          .thenReturn("42");
+      expect(mock.methodWithNormalArgs(43), equals("43"));
     });
 
-    test('should mock hashCode', () {
+    test("should mock hashCode", () {
       named(mock, hashCode: 42);
       expect(mock.hashCode, equals(42));
     });
 
-    test('should have toString as name when it is not mocked', () {
-      named(mock, name: 'Cat');
-      expect(mock.toString(), equals('Cat'));
+    test("should have toString as name when it is not mocked", () {
+      named(mock, name: "Cat");
+      expect(mock.toString(), equals("Cat"));
     });
 
-    test('should mock equals between mocks when givenHashCode is equals', () {
+    test("should mock equals between mocks when givenHashCode is equals", () {
       var anotherMock = named(_MockedClass(), hashCode: 42);
       named(mock, hashCode: 42);
       expect(mock == anotherMock, isTrue);
diff --git a/test/deprecated_apis/until_called_test.dart b/test/deprecated_apis/until_called_test.dart
index f4e6801..92ed487 100644
--- a/test/deprecated_apis/until_called_test.dart
+++ b/test/deprecated_apis/until_called_test.dart
@@ -86,7 +86,8 @@
   });
 
   group('untilCalled', () {
-    var streamController = StreamController<CallMethodsEvent>.broadcast();
+    StreamController<CallMethodsEvent> streamController =
+        StreamController.broadcast();
 
     group('on methods already called', () {
       test('waits for method with normal args', () async {
diff --git a/test/deprecated_apis/verify_test.dart b/test/deprecated_apis/verify_test.dart
index 74cfdcb..a8c870c 100644
--- a/test/deprecated_apis/verify_test.dart
+++ b/test/deprecated_apis/verify_test.dart
@@ -57,7 +57,7 @@
 
 class _MockedClass extends Mock implements _RealClass {}
 
-void expectFail(String expectedMessage, void Function() expectedToFail) {
+void expectFail(String expectedMessage, dynamic expectedToFail()) {
   try {
     expectedToFail();
     fail('It was expected to fail!');
diff --git a/test/invocation_matcher_test.dart b/test/invocation_matcher_test.dart
index dc5bb52..12eae07 100644
--- a/test/invocation_matcher_test.dart
+++ b/test/invocation_matcher_test.dart
@@ -66,9 +66,9 @@
       shouldFail(
         call1,
         isInvocation(call3),
-        'Expected: lie(<false>) '
+        "Expected: lie(<false>) "
         "Actual: <Instance of '${call3.runtimeType}'> "
-        'Which: Does not match lie(<true>)',
+        "Which: Does not match lie(<true>)",
       );
     });
 
@@ -102,9 +102,9 @@
         call1,
         isInvocation(call3),
         // RegExp needed because of https://github.com/dart-lang/sdk/issues/33565
-        RegExp('Expected: set value=? <false> '
+        RegExp("Expected: set value=? <false> "
             "Actual: <Instance of '${call3.runtimeType}'> "
-            'Which: Does not match set value=? <true>'),
+            "Which: Does not match set value=? <true>"),
       );
     });
   });
@@ -118,7 +118,7 @@
       shouldFail(
         call,
         invokes(#say, positionalArguments: [isNull]),
-        'Expected: say(null) '
+        "Expected: say(null) "
         "Actual: <Instance of '${call.runtimeType}'> "
         "Which: Does not match say('Hello')",
       );
diff --git a/test/mockito_test.dart b/test/mockito_test.dart
index e31cde2..1b80150 100644
--- a/test/mockito_test.dart
+++ b/test/mockito_test.dart
@@ -21,16 +21,16 @@
 
 class _RealClass {
   _RealClass innerObj;
-  String methodWithoutArgs() => 'Real';
-  String methodWithNormalArgs(int x) => 'Real';
-  String methodWithListArgs(List<int> x) => 'Real';
-  String methodWithPositionalArgs(int x, [int y]) => 'Real';
-  String methodWithNamedArgs(int x, {int y}) => 'Real';
-  String methodWithTwoNamedArgs(int x, {int y, int z}) => 'Real';
-  String methodWithObjArgs(_RealClass x) => 'Real';
-  Future<String> methodReturningFuture() => Future.value('Real');
-  Stream<String> methodReturningStream() => Stream.fromIterable(['Real']);
-  String get getter => 'Real';
+  String methodWithoutArgs() => "Real";
+  String methodWithNormalArgs(int x) => "Real";
+  String methodWithListArgs(List<int> x) => "Real";
+  String methodWithPositionalArgs(int x, [int y]) => "Real";
+  String methodWithNamedArgs(int x, {int y}) => "Real";
+  String methodWithTwoNamedArgs(int x, {int y, int z}) => "Real";
+  String methodWithObjArgs(_RealClass x) => "Real";
+  Future<String> methodReturningFuture() => Future.value("Real");
+  Stream<String> methodReturningStream() => Stream.fromIterable(["Real"]);
+  String get getter => "Real";
 }
 
 abstract class _Foo {
@@ -43,30 +43,30 @@
 
   String baz();
 
-  String quux() => 'Real';
+  String quux() => "Real";
 }
 
 class _MockFoo extends _AbstractFoo with Mock {}
 
 class _MockedClass extends Mock implements _RealClass {}
 
-void expectFail(String expectedMessage, void Function() expectedToFail) {
+void expectFail(String expectedMessage, dynamic expectedToFail()) {
   try {
     expectedToFail();
-    fail('It was expected to fail!');
+    fail("It was expected to fail!");
   } catch (e) {
     if (!(e is TestFailure)) {
       rethrow;
     } else {
       if (expectedMessage != e.message) {
-        throw TestFailure('Failed, but with wrong message: ${e.message}');
+        throw TestFailure("Failed, but with wrong message: ${e.message}");
       }
     }
   }
 }
 
-String noMatchingCallsFooter = '(If you called `verify(...).called(0);`, '
-    'please instead use `verifyNever(...);`.)';
+String noMatchingCallsFooter = "(If you called `verify(...).called(0);`, "
+    "please instead use `verifyNever(...);`.)";
 
 void main() {
   _MockedClass mock;
@@ -83,229 +83,229 @@
     resetMockitoState();
   });
 
-  group('mixin support', () {
-    test('should work', () {
+  group("mixin support", () {
+    test("should work", () {
       var foo = _MockFoo();
       when(foo.baz()).thenReturn('baz');
       expect(foo.bar(), 'baz');
     });
   });
 
-  group('when()', () {
-    test('should mock method without args', () {
-      when(mock.methodWithoutArgs()).thenReturn('A');
-      expect(mock.methodWithoutArgs(), equals('A'));
+  group("when()", () {
+    test("should mock method without args", () {
+      when(mock.methodWithoutArgs()).thenReturn("A");
+      expect(mock.methodWithoutArgs(), equals("A"));
     });
 
-    test('should mock method with normal args', () {
-      when(mock.methodWithNormalArgs(42)).thenReturn('Ultimate Answer');
+    test("should mock method with normal args", () {
+      when(mock.methodWithNormalArgs(42)).thenReturn("Ultimate Answer");
       expect(mock.methodWithNormalArgs(43), isNull);
-      expect(mock.methodWithNormalArgs(42), equals('Ultimate Answer'));
+      expect(mock.methodWithNormalArgs(42), equals("Ultimate Answer"));
     });
 
-    test('should mock method with mock args', () {
+    test("should mock method with mock args", () {
       var m1 = _MockedClass();
-      when(mock.methodWithObjArgs(m1)).thenReturn('Ultimate Answer');
+      when(mock.methodWithObjArgs(m1)).thenReturn("Ultimate Answer");
       expect(mock.methodWithObjArgs(_MockedClass()), isNull);
-      expect(mock.methodWithObjArgs(m1), equals('Ultimate Answer'));
+      expect(mock.methodWithObjArgs(m1), equals("Ultimate Answer"));
     });
 
-    test('should mock method with positional args', () {
-      when(mock.methodWithPositionalArgs(42, 17)).thenReturn('Answer and...');
+    test("should mock method with positional args", () {
+      when(mock.methodWithPositionalArgs(42, 17)).thenReturn("Answer and...");
       expect(mock.methodWithPositionalArgs(42), isNull);
       expect(mock.methodWithPositionalArgs(42, 18), isNull);
-      expect(mock.methodWithPositionalArgs(42, 17), equals('Answer and...'));
+      expect(mock.methodWithPositionalArgs(42, 17), equals("Answer and..."));
     });
 
-    test('should mock method with named args', () {
-      when(mock.methodWithNamedArgs(42, y: 17)).thenReturn('Why answer?');
+    test("should mock method with named args", () {
+      when(mock.methodWithNamedArgs(42, y: 17)).thenReturn("Why answer?");
       expect(mock.methodWithNamedArgs(42), isNull);
       expect(mock.methodWithNamedArgs(42, y: 18), isNull);
-      expect(mock.methodWithNamedArgs(42, y: 17), equals('Why answer?'));
+      expect(mock.methodWithNamedArgs(42, y: 17), equals("Why answer?"));
     });
 
-    test('should mock method with List args', () {
-      when(mock.methodWithListArgs([42])).thenReturn('Ultimate answer');
+    test("should mock method with List args", () {
+      when(mock.methodWithListArgs([42])).thenReturn("Ultimate answer");
       expect(mock.methodWithListArgs([43]), isNull);
-      expect(mock.methodWithListArgs([42]), equals('Ultimate answer'));
+      expect(mock.methodWithListArgs([42]), equals("Ultimate answer"));
     });
 
-    test('should mock method with argument matcher', () {
+    test("should mock method with argument matcher", () {
       when(mock.methodWithNormalArgs(argThat(greaterThan(100))))
-          .thenReturn('A lot!');
+          .thenReturn("A lot!");
       expect(mock.methodWithNormalArgs(100), isNull);
-      expect(mock.methodWithNormalArgs(101), equals('A lot!'));
+      expect(mock.methodWithNormalArgs(101), equals("A lot!"));
     });
 
-    test('should mock method with any argument matcher', () {
-      when(mock.methodWithNormalArgs(any)).thenReturn('A lot!');
-      expect(mock.methodWithNormalArgs(100), equals('A lot!'));
-      expect(mock.methodWithNormalArgs(101), equals('A lot!'));
+    test("should mock method with any argument matcher", () {
+      when(mock.methodWithNormalArgs(any)).thenReturn("A lot!");
+      expect(mock.methodWithNormalArgs(100), equals("A lot!"));
+      expect(mock.methodWithNormalArgs(101), equals("A lot!"));
     });
 
-    test('should mock method with any list argument matcher', () {
-      when(mock.methodWithListArgs(any)).thenReturn('A lot!');
-      expect(mock.methodWithListArgs([42]), equals('A lot!'));
-      expect(mock.methodWithListArgs([43]), equals('A lot!'));
+    test("should mock method with any list argument matcher", () {
+      when(mock.methodWithListArgs(any)).thenReturn("A lot!");
+      expect(mock.methodWithListArgs([42]), equals("A lot!"));
+      expect(mock.methodWithListArgs([43]), equals("A lot!"));
     });
 
-    test('should mock method with multiple named args and matchers', () {
+    test("should mock method with multiple named args and matchers", () {
       when(mock.methodWithTwoNamedArgs(any, y: anyNamed('y')))
-          .thenReturn('x y');
+          .thenReturn("x y");
       when(mock.methodWithTwoNamedArgs(any, z: anyNamed('z')))
-          .thenReturn('x z');
+          .thenReturn("x z");
       if (isNsmForwarding) {
-        expect(mock.methodWithTwoNamedArgs(42), 'x z');
+        expect(mock.methodWithTwoNamedArgs(42), "x z");
       } else {
         expect(mock.methodWithTwoNamedArgs(42), isNull);
       }
-      expect(mock.methodWithTwoNamedArgs(42, y: 18), equals('x y'));
-      expect(mock.methodWithTwoNamedArgs(42, z: 17), equals('x z'));
+      expect(mock.methodWithTwoNamedArgs(42, y: 18), equals("x y"));
+      expect(mock.methodWithTwoNamedArgs(42, z: 17), equals("x z"));
       expect(mock.methodWithTwoNamedArgs(42, y: 18, z: 17), isNull);
       when(mock.methodWithTwoNamedArgs(any, y: anyNamed('y'), z: anyNamed('z')))
-          .thenReturn('x y z');
-      expect(mock.methodWithTwoNamedArgs(42, y: 18, z: 17), equals('x y z'));
+          .thenReturn("x y z");
+      expect(mock.methodWithTwoNamedArgs(42, y: 18, z: 17), equals("x y z"));
     });
 
-    test('should mock method with mix of argument matchers and real things',
+    test("should mock method with mix of argument matchers and real things",
         () {
       when(mock.methodWithPositionalArgs(argThat(greaterThan(100)), 17))
-          .thenReturn('A lot with 17');
+          .thenReturn("A lot with 17");
       expect(mock.methodWithPositionalArgs(100, 17), isNull);
       expect(mock.methodWithPositionalArgs(101, 18), isNull);
-      expect(mock.methodWithPositionalArgs(101, 17), equals('A lot with 17'));
+      expect(mock.methodWithPositionalArgs(101, 17), equals("A lot with 17"));
     });
 
-    test('should mock getter', () {
-      when(mock.getter).thenReturn('A');
-      expect(mock.getter, equals('A'));
+    test("should mock getter", () {
+      when(mock.getter).thenReturn("A");
+      expect(mock.getter, equals("A"));
     });
 
-    test('should have hashCode when it is not mocked', () {
+    test("should have hashCode when it is not mocked", () {
       expect(mock.hashCode, isNotNull);
     });
 
-    test('should have default toString when it is not mocked', () {
+    test("should have default toString when it is not mocked", () {
       expect(mock.toString(), equals('_MockedClass'));
     });
 
-    test('should use identical equality between it is not mocked', () {
+    test("should use identical equality between it is not mocked", () {
       var anotherMock = _MockedClass();
       expect(mock == anotherMock, isFalse);
       expect(mock == mock, isTrue);
     });
 
-    test('should mock method with thrown result', () {
+    test("should mock method with thrown result", () {
       when(mock.methodWithNormalArgs(any)).thenThrow(StateError('Boo'));
       expect(() => mock.methodWithNormalArgs(42), throwsStateError);
     });
 
-    test('should mock method with calculated result', () {
+    test("should mock method with calculated result", () {
       when(mock.methodWithNormalArgs(any)).thenAnswer(
           (Invocation inv) => inv.positionalArguments[0].toString());
-      expect(mock.methodWithNormalArgs(43), equals('43'));
-      expect(mock.methodWithNormalArgs(42), equals('42'));
+      expect(mock.methodWithNormalArgs(43), equals("43"));
+      expect(mock.methodWithNormalArgs(42), equals("42"));
     });
 
-    test('should return mock to make simple oneline mocks', () {
+    test("should return mock to make simple oneline mocks", () {
       _RealClass mockWithSetup = _MockedClass();
-      when(mockWithSetup.methodWithoutArgs()).thenReturn('oneline');
-      expect(mockWithSetup.methodWithoutArgs(), equals('oneline'));
+      when(mockWithSetup.methodWithoutArgs()).thenReturn("oneline");
+      expect(mockWithSetup.methodWithoutArgs(), equals("oneline"));
     });
 
-    test('should use latest matching when definition', () {
-      when(mock.methodWithoutArgs()).thenReturn('A');
-      when(mock.methodWithoutArgs()).thenReturn('B');
-      expect(mock.methodWithoutArgs(), equals('B'));
+    test("should use latest matching when definition", () {
+      when(mock.methodWithoutArgs()).thenReturn("A");
+      when(mock.methodWithoutArgs()).thenReturn("B");
+      expect(mock.methodWithoutArgs(), equals("B"));
     });
 
-    test('should mock method with calculated result', () {
-      when(mock.methodWithNormalArgs(argThat(equals(43)))).thenReturn('43');
-      when(mock.methodWithNormalArgs(argThat(equals(42)))).thenReturn('42');
-      expect(mock.methodWithNormalArgs(43), equals('43'));
+    test("should mock method with calculated result", () {
+      when(mock.methodWithNormalArgs(argThat(equals(43)))).thenReturn("43");
+      when(mock.methodWithNormalArgs(argThat(equals(42)))).thenReturn("42");
+      expect(mock.methodWithNormalArgs(43), equals("43"));
     });
 
     // Error path tests.
-    test('should throw if `when` is called while stubbing', () {
+    test("should throw if `when` is called while stubbing", () {
       expect(() {
         var responseHelper = () {
           var mock2 = _MockedClass();
-          when(mock2.getter).thenReturn('A');
+          when(mock2.getter).thenReturn("A");
           return mock2;
         };
         when(mock.innerObj).thenReturn(responseHelper());
       }, throwsStateError);
     });
 
-    test('thenReturn throws if provided Future', () {
+    test("thenReturn throws if provided Future", () {
       expect(
           () => when(mock.methodReturningFuture())
-              .thenReturn(Future.value('stub')),
+              .thenReturn(Future.value("stub")),
           throwsArgumentError);
     });
 
-    test('thenReturn throws if provided Stream', () {
+    test("thenReturn throws if provided Stream", () {
       expect(
           () => when(mock.methodReturningStream())
-              .thenReturn(Stream.fromIterable(['stub'])),
+              .thenReturn(Stream.fromIterable(["stub"])),
           throwsArgumentError);
     });
 
-    test('thenAnswer supports stubbing method returning a Future', () async {
+    test("thenAnswer supports stubbing method returning a Future", () async {
       when(mock.methodReturningFuture())
-          .thenAnswer((_) => Future.value('stub'));
+          .thenAnswer((_) => Future.value("stub"));
 
-      expect(await mock.methodReturningFuture(), 'stub');
+      expect(await mock.methodReturningFuture(), "stub");
     });
 
-    test('thenAnswer supports stubbing method returning a Stream', () async {
+    test("thenAnswer supports stubbing method returning a Stream", () async {
       when(mock.methodReturningStream())
-          .thenAnswer((_) => Stream.fromIterable(['stub']));
+          .thenAnswer((_) => Stream.fromIterable(["stub"]));
 
-      expect(await mock.methodReturningStream().toList(), ['stub']);
+      expect(await mock.methodReturningStream().toList(), ["stub"]);
     });
 
-    test('should throw if named matcher is passed as the wrong name', () {
+    test("should throw if named matcher is passed as the wrong name", () {
       expect(() {
-        when(mock.methodWithNamedArgs(argThat(equals(42)), y: anyNamed('z')))
-            .thenReturn('99');
+        when(mock.methodWithNamedArgs(argThat(equals(42)), y: anyNamed("z")))
+            .thenReturn("99");
       }, throwsArgumentError);
     });
 
-    test('should throw if attempting to stub a real method', () {
+    test("should throw if attempting to stub a real method", () {
       var foo = _MockFoo();
       expect(() {
-        when(foo.quux()).thenReturn('Stub');
+        when(foo.quux()).thenReturn("Stub");
       }, throwsStateError);
     });
   });
 
-  group('throwOnMissingStub', () {
-    test('should throw when a mock was called without a matching stub', () {
+  group("throwOnMissingStub", () {
+    test("should throw when a mock was called without a matching stub", () {
       throwOnMissingStub(mock);
-      when(mock.methodWithNormalArgs(42)).thenReturn('Ultimate Answer');
+      when(mock.methodWithNormalArgs(42)).thenReturn("Ultimate Answer");
       expect(
         () => (mock).methodWithoutArgs(),
         throwsNoSuchMethodError,
       );
     });
 
-    test('should not throw when a mock was called with a matching stub', () {
+    test("should not throw when a mock was called with a matching stub", () {
       throwOnMissingStub(mock);
-      when(mock.methodWithoutArgs()).thenReturn('A');
+      when(mock.methodWithoutArgs()).thenReturn("A");
       expect(() => mock.methodWithoutArgs(), returnsNormally);
     });
   });
 
   test(
-      'reports an error when using an argument matcher outside of stubbing or '
-      'verification', () {
+      "reports an error when using an argument matcher outside of stubbing or "
+      "verification", () {
     expect(() => mock.methodWithNormalArgs(any), throwsArgumentError);
   });
 
   test(
-      'reports an error when using an argument matcher in a position other '
-      'than an argument for the stubbed method', () {
+      "reports an error when using an argument matcher in a position other "
+      "than an argument for the stubbed method", () {
     expect(() => when(mock.methodWithListArgs(List.filled(7, any))),
         throwsArgumentError);
   });
diff --git a/test/until_called_test.dart b/test/until_called_test.dart
index 4a0b03f..634c59c 100644
--- a/test/until_called_test.dart
+++ b/test/until_called_test.dart
@@ -81,7 +81,8 @@
   });
 
   group('untilCalled', () {
-    var streamController = StreamController<CallMethodsEvent>.broadcast();
+    StreamController<CallMethodsEvent> streamController =
+        StreamController.broadcast();
 
     group('on methods already called', () {
       test('waits for method without args', () async {
diff --git a/test/verify_test.dart b/test/verify_test.dart
index 7622a2b..0c41c29 100644
--- a/test/verify_test.dart
+++ b/test/verify_test.dart
@@ -54,7 +54,7 @@
 
 class _MockedClass extends Mock implements _RealClass {}
 
-void expectFail(Pattern expectedMessage, void Function() expectedToFail) {
+void expectFail(Pattern expectedMessage, dynamic expectedToFail()) {
   try {
     expectedToFail();
     fail('It was expected to fail!');