diff --git a/analysis_options.yaml b/analysis_options.yaml
index e88b5f1..10a2849 100644
--- a/analysis_options.yaml
+++ b/analysis_options.yaml
@@ -1,3 +1,5 @@
+include: package:pedantic/analysis_options.yaml
+
 analyzer:
 
 linter:
@@ -20,7 +22,6 @@
     - prefer_is_not_empty
     - slash_for_doc_comments
     - sort_unnamed_constructors_first
-    - super_goes_last
     # - type_annotate_public_apis
     - type_init_formals
     - unnecessary_brace_in_string_interps
diff --git a/e2e_test/bin/async_worker.dart b/e2e_test/bin/async_worker.dart
index 4573473..ddd530c 100644
--- a/e2e_test/bin/async_worker.dart
+++ b/e2e_test/bin/async_worker.dart
@@ -10,5 +10,5 @@
 /// This worker can run in one of two ways: normally, using stdin/stdout, or
 /// in an isolate, communicating over a [SendPort].
 Future main(List<String> args, [SendPort sendPort]) async {
-  await new ExampleAsyncWorker(sendPort).run();
+  await ExampleAsyncWorker(sendPort).run();
 }
diff --git a/e2e_test/bin/async_worker_in_isolate.dart b/e2e_test/bin/async_worker_in_isolate.dart
index 7b245f6..fce1eff 100644
--- a/e2e_test/bin/async_worker_in_isolate.dart
+++ b/e2e_test/bin/async_worker_in_isolate.dart
@@ -15,9 +15,9 @@
 /// to use this code to do additional work, for example post processing one of
 /// the output files.
 Future main(List<String> args, SendPort message) async {
-  var receivePort = new ReceivePort();
+  var receivePort = ReceivePort();
   await Isolate.spawnUri(
-      new Uri.file('async_worker.dart'), [], receivePort.sendPort);
+      Uri.file('async_worker.dart'), [], receivePort.sendPort);
 
   var worker = await ForwardsToIsolateAsyncWorker.create(receivePort);
   await worker.run();
diff --git a/e2e_test/bin/sync_worker.dart b/e2e_test/bin/sync_worker.dart
index e87b1c8..9bdcc77 100644
--- a/e2e_test/bin/sync_worker.dart
+++ b/e2e_test/bin/sync_worker.dart
@@ -5,5 +5,5 @@
 import 'package:e2e_test/sync_worker.dart';
 
 void main() {
-  new ExampleSyncWorker().run();
+  ExampleSyncWorker().run();
 }
diff --git a/e2e_test/lib/async_worker.dart b/e2e_test/lib/async_worker.dart
index ee080a9..3c7607b 100644
--- a/e2e_test/lib/async_worker.dart
+++ b/e2e_test/lib/async_worker.dart
@@ -12,10 +12,10 @@
 class ExampleAsyncWorker extends AsyncWorkerLoop {
   /// Set [sendPort] to run in an isolate.
   ExampleAsyncWorker([SendPort sendPort])
-      : super(connection: new AsyncWorkerConnection(sendPort: sendPort));
+      : super(connection: AsyncWorkerConnection(sendPort: sendPort));
 
   Future<WorkResponse> performRequest(WorkRequest request) async {
-    return new WorkResponse()
+    return WorkResponse()
       ..exitCode = 0
       ..output = request.arguments.join('\n');
   }
diff --git a/e2e_test/lib/forwards_to_isolate_async_worker.dart b/e2e_test/lib/forwards_to_isolate_async_worker.dart
index 47cf101..a09d3ee 100644
--- a/e2e_test/lib/forwards_to_isolate_async_worker.dart
+++ b/e2e_test/lib/forwards_to_isolate_async_worker.dart
@@ -14,7 +14,7 @@
 
   static Future<ForwardsToIsolateAsyncWorker> create(
       ReceivePort receivePort) async {
-    return new ForwardsToIsolateAsyncWorker(
+    return ForwardsToIsolateAsyncWorker(
         await IsolateDriverConnection.create(receivePort));
   }
 
diff --git a/e2e_test/lib/sync_worker.dart b/e2e_test/lib/sync_worker.dart
index 7c98dbe..270c555 100644
--- a/e2e_test/lib/sync_worker.dart
+++ b/e2e_test/lib/sync_worker.dart
@@ -8,7 +8,7 @@
 /// separated by newlines.
 class ExampleSyncWorker extends SyncWorkerLoop {
   WorkResponse performRequest(WorkRequest request) {
-    return new WorkResponse()
+    return WorkResponse()
       ..exitCode = 0
       ..output = request.arguments.join('\n');
   }
diff --git a/e2e_test/test/e2e_test.dart b/e2e_test/test/e2e_test.dart
index 1757139..028213f 100644
--- a/e2e_test/test/e2e_test.dart
+++ b/e2e_test/test/e2e_test.dart
@@ -27,7 +27,7 @@
   BazelWorkerDriver driver;
   group(groupName, () {
     setUp(() {
-      driver = new BazelWorkerDriver(spawnWorker);
+      driver = BazelWorkerDriver(spawnWorker);
     });
 
     tearDown(() async {
@@ -48,10 +48,9 @@
 /// completed with the correct response.
 Future _doRequests(BazelWorkerDriver driver, {int count}) async {
   count ??= 100;
-  var requests = new List.generate(count, (requestNum) {
-    var request = new WorkRequest();
-    request.arguments
-        .addAll(new List.generate(requestNum, (argNum) => '$argNum'));
+  var requests = List.generate(count, (requestNum) {
+    var request = WorkRequest();
+    request.arguments.addAll(List.generate(requestNum, (argNum) => '$argNum'));
     return request;
   });
   var responses = await Future.wait(requests.map(driver.doWork));
diff --git a/lib/src/async_message_grouper.dart b/lib/src/async_message_grouper.dart
index 3044bbe..dba4748 100644
--- a/lib/src/async_message_grouper.dart
+++ b/lib/src/async_message_grouper.dart
@@ -6,6 +6,7 @@
 import 'dart:collection';
 
 import 'package:async/async.dart';
+import 'package:pedantic/pedantic.dart';
 
 import 'message_grouper.dart';
 import 'message_grouper_state.dart';
@@ -14,7 +15,7 @@
 /// base-128 encoded lengths interleaved with raw data.
 class AsyncMessageGrouper implements MessageGrouper {
   /// Current state for reading in messages;
-  final _state = new MessageGrouperState();
+  final _state = MessageGrouperState();
 
   /// The input stream.
   final StreamQueue<List<int>> _inputQueue;
@@ -23,10 +24,10 @@
   bool _inputQueueCancelled = false;
 
   /// The current buffer.
-  final Queue<int> _buffer = new Queue<int>();
+  final Queue<int> _buffer = Queue<int>();
 
   AsyncMessageGrouper(Stream<List<int>> inputStream)
-      : _inputQueue = new StreamQueue(inputStream);
+      : _inputQueue = StreamQueue(inputStream);
 
   /// Returns the next full message that is received, or null if none are left.
   Future<List<int>> get next async {
@@ -41,7 +42,7 @@
       }
 
       // If there is nothing left in the queue then cancel the subscription.
-      if (message == null) _cancel();
+      if (message == null) unawaited(_cancel());
 
       return message;
     } catch (e) {
@@ -57,7 +58,7 @@
       _inputQueueCancelled = true;
       return _inputQueue.cancel();
     }
-    return new Future.value(null);
+    return Future.value(null);
   }
 
   /// Stop listening to the stream for further updates.
diff --git a/lib/src/driver/driver.dart b/lib/src/driver/driver.dart
index 8a3fb04..c4d1e92 100644
--- a/lib/src/driver/driver.dart
+++ b/lib/src/driver/driver.dart
@@ -10,7 +10,7 @@
 import '../worker_protocol.pb.dart';
 import 'driver_connection.dart';
 
-typedef Future<Process> SpawnWorker();
+typedef SpawnWorker = Future<Process> Function();
 
 /// A driver for talking to a bazel worker.
 ///
@@ -39,7 +39,7 @@
   final _spawningWorkers = <Future<Process>>[];
 
   /// Work requests that haven't been started yet.
-  final _workQueue = new Queue<_WorkAttempt>();
+  final _workQueue = Queue<_WorkAttempt>();
 
   /// Factory method that spawns a worker process.
   final SpawnWorker _spawnWorker;
@@ -58,7 +58,7 @@
   /// available worker.
   Future<WorkResponse> doWork(WorkRequest request,
       {Function(Future<WorkResponse>) trackWork}) {
-    var attempt = new _WorkAttempt(request, trackWork: trackWork);
+    var attempt = _WorkAttempt(request, trackWork: trackWork);
     _workQueue.add(attempt);
     _runWorkQueue();
     return attempt.response;
@@ -88,7 +88,7 @@
     if (_workQueue.isEmpty) return;
     if (_numWorkers == _maxWorkers && _idleWorkers.isEmpty) return;
     if (_numWorkers > _maxWorkers) {
-      throw new StateError('Internal error, created to many workers. Please '
+      throw StateError('Internal error, created to many workers. Please '
           'file a bug at https://github.com/dart-lang/bazel_worker/issues/new');
     }
 
@@ -106,7 +106,7 @@
         _spawningWorkers.remove(futureWorker);
         _readyWorkers.add(worker);
 
-        _workerConnections[worker] = new StdDriverConnection.forWorker(worker);
+        _workerConnections[worker] = StdDriverConnection.forWorker(worker);
         _runWorker(worker, attempt);
 
         // When the worker exits we should retry running the work queue in case
@@ -148,11 +148,11 @@
           rescheduled = _tryReschedule(attempt);
           if (rescheduled) return;
           stderr.writeln('Failed to run request ${attempt.request}');
-          response = new WorkResponse()
+          response = WorkResponse()
             ..exitCode = EXIT_CODE_ERROR
             ..output =
                 'Invalid response from worker, this probably means it wrote '
-                'invalid output or died.';
+                    'invalid output or died.';
         }
         attempt.responseCompleter.complete(response);
         _cleanUp(worker);
@@ -164,7 +164,7 @@
       if (!attempt.responseCompleter.isCompleted) {
         rescheduled = _tryReschedule(attempt);
         if (rescheduled) return;
-        var response = new WorkResponse()
+        var response = WorkResponse()
           ..exitCode = EXIT_CODE_ERROR
           ..output = 'Error running worker:\n$e\n$s';
         attempt.responseCompleter.complete(response);
@@ -218,7 +218,7 @@
 /// [WorkResponse], and the number of times it has been retried.
 class _WorkAttempt {
   final WorkRequest request;
-  final responseCompleter = new Completer<WorkResponse>();
+  final responseCompleter = Completer<WorkResponse>();
   final Function(Future<WorkResponse>) trackWork;
 
   Future<WorkResponse> get response => responseCompleter.future;
@@ -228,4 +228,4 @@
   _WorkAttempt(this.request, {this.trackWork});
 }
 
-final _workerConnections = new Expando<DriverConnection>('connection');
+final _workerConnections = Expando<DriverConnection>('connection');
diff --git a/lib/src/driver/driver_connection.dart b/lib/src/driver/driver_connection.dart
index f30bf84..0a3cb78 100644
--- a/lib/src/driver/driver_connection.dart
+++ b/lib/src/driver/driver_connection.dart
@@ -33,12 +33,11 @@
 
   StdDriverConnection(
       {Stream<List<int>> inputStream, StreamSink<List<int>> outputStream})
-      : _messageGrouper = new AsyncMessageGrouper(inputStream ?? stdin),
+      : _messageGrouper = AsyncMessageGrouper(inputStream ?? stdin),
         _outputStream = outputStream ?? stdout;
 
-  factory StdDriverConnection.forWorker(Process worker) =>
-      new StdDriverConnection(
-          inputStream: worker.stdout, outputStream: worker.stdin);
+  factory StdDriverConnection.forWorker(Process worker) => StdDriverConnection(
+      inputStream: worker.stdout, outputStream: worker.stdin);
 
   /// Note: This will attempts to recover from invalid proto messages by parsing
   /// them as strings. This is a common error case for workers (they print a
@@ -53,12 +52,12 @@
 
     WorkResponse response;
     try {
-      response = new WorkResponse.fromBuffer(buffer);
+      response = WorkResponse.fromBuffer(buffer);
     } catch (_) {
       try {
         // Try parsing the message as a string and set that as the output.
         var output = utf8.decode(buffer);
-        var response = new WorkResponse()
+        var response = WorkResponse()
           ..exitCode = EXIT_CODE_ERROR
           ..output = 'Worker sent an invalid response:\n$output';
         return response;
@@ -94,10 +93,10 @@
   /// [receivePort] attached to the [SendPort] that the isolate was created
   /// with.
   static Future<IsolateDriverConnection> create(ReceivePort receivePort) async {
-    var receivePortIterator = new StreamIterator(receivePort);
+    var receivePortIterator = StreamIterator(receivePort);
     await receivePortIterator.moveNext();
     var sendPort = receivePortIterator.current as SendPort;
-    return new IsolateDriverConnection._(receivePortIterator, sendPort);
+    return IsolateDriverConnection._(receivePortIterator, sendPort);
   }
 
   @override
diff --git a/lib/src/message_grouper_state.dart b/lib/src/message_grouper_state.dart
index 6ee524b..91419bc 100644
--- a/lib/src/message_grouper_state.dart
+++ b/lib/src/message_grouper_state.dart
@@ -27,7 +27,7 @@
     if (!_lengthReader.done) {
       _lengthReader.readByte(byte);
       if (_lengthReader.done) {
-        _messageReader = new _MessageReader(_lengthReader.length);
+        _messageReader = _MessageReader(_lengthReader.length);
       }
     } else {
       assert(_messageReader != null);
@@ -45,7 +45,7 @@
 
   /// Reset the state so that we are ready to receive the next message.
   void reset() {
-    _lengthReader = new _LengthReader();
+    _lengthReader = _LengthReader();
     _messageReader = null;
   }
 }
@@ -83,7 +83,7 @@
     // Check for the last byte in the length, and then read it.
     if ((byte & 0x80) == 0) {
       _done = true;
-      var reader = new CodedBufferReader(_buffer);
+      var reader = CodedBufferReader(_buffer);
       _length = reader.readInt32();
     }
   }
@@ -112,7 +112,7 @@
   int _numMessageBytesReceived = 0;
 
   _MessageReader(int length)
-      : _message = new Uint8List(length),
+      : _message = Uint8List(length),
         _length = length,
         _done = length == 0;
 
diff --git a/lib/src/sync_message_grouper.dart b/lib/src/sync_message_grouper.dart
index 20a1139..d86ef8d 100644
--- a/lib/src/sync_message_grouper.dart
+++ b/lib/src/sync_message_grouper.dart
@@ -9,7 +9,7 @@
 
 /// Groups bytes in delimited proto format into the bytes for each message.
 class SyncMessageGrouper implements MessageGrouper {
-  final _state = new MessageGrouperState();
+  final _state = MessageGrouperState();
   final Stdin _stdin;
 
   SyncMessageGrouper(this._stdin);
diff --git a/lib/src/utils.dart b/lib/src/utils.dart
index e34112d..609b435 100644
--- a/lib/src/utils.dart
+++ b/lib/src/utils.dart
@@ -7,14 +7,14 @@
 import 'package:protobuf/protobuf.dart';
 
 List<int> protoToDelimitedBuffer(GeneratedMessage message) {
-  var messageBuffer = new CodedBufferWriter();
+  var messageBuffer = CodedBufferWriter();
   message.writeToCodedBufferWriter(messageBuffer);
 
-  var delimiterBuffer = new CodedBufferWriter();
+  var delimiterBuffer = CodedBufferWriter();
   delimiterBuffer.writeInt32NoTag(messageBuffer.lengthInBytes);
 
-  var result = new Uint8List(
-      messageBuffer.lengthInBytes + delimiterBuffer.lengthInBytes);
+  var result =
+      Uint8List(messageBuffer.lengthInBytes + delimiterBuffer.lengthInBytes);
 
   delimiterBuffer.writeTo(result);
   messageBuffer.writeTo(result, delimiterBuffer.lengthInBytes);
diff --git a/lib/src/worker/async_worker_loop.dart b/lib/src/worker/async_worker_loop.dart
index 29f6ff8..db22b9a 100644
--- a/lib/src/worker/async_worker_loop.dart
+++ b/lib/src/worker/async_worker_loop.dart
@@ -16,7 +16,7 @@
   final AsyncWorkerConnection connection;
 
   AsyncWorkerLoop({AsyncWorkerConnection connection})
-      : this.connection = connection ?? new StdAsyncWorkerConnection();
+      : this.connection = connection ?? StdAsyncWorkerConnection();
 
   /// Perform a single [WorkRequest], and return a [WorkResponse].
   Future<WorkResponse> performRequest(WorkRequest request);
@@ -29,10 +29,10 @@
       try {
         var request = await connection.readRequest();
         if (request == null) break;
-        var printMessages = new StringBuffer();
+        var printMessages = StringBuffer();
         response = await runZoned(() => performRequest(request),
             zoneSpecification:
-                new ZoneSpecification(print: (self, parent, zone, message) {
+                ZoneSpecification(print: (self, parent, zone, message) {
           printMessages.writeln();
           printMessages.write(message);
         }));
@@ -42,7 +42,7 @@
         // In case they forget to set this.
         response.exitCode ??= EXIT_CODE_OK;
       } catch (e, s) {
-        response = new WorkResponse()
+        response = WorkResponse()
           ..exitCode = EXIT_CODE_ERROR
           ..output = '$e\n$s';
       }
diff --git a/lib/src/worker/sync_worker_loop.dart b/lib/src/worker/sync_worker_loop.dart
index e1b9aaf..799ec65 100644
--- a/lib/src/worker/sync_worker_loop.dart
+++ b/lib/src/worker/sync_worker_loop.dart
@@ -15,7 +15,7 @@
   final SyncWorkerConnection connection;
 
   SyncWorkerLoop({SyncWorkerConnection connection})
-      : this.connection = connection ?? new StdSyncWorkerConnection();
+      : this.connection = connection ?? StdSyncWorkerConnection();
 
   /// Perform a single [WorkRequest], and return a [WorkResponse].
   WorkResponse performRequest(WorkRequest request);
@@ -27,9 +27,9 @@
       try {
         var request = connection.readRequest();
         if (request == null) break;
-        var printMessages = new StringBuffer();
+        var printMessages = StringBuffer();
         response = runZoned(() => performRequest(request), zoneSpecification:
-            new ZoneSpecification(print: (self, parent, zone, message) {
+            ZoneSpecification(print: (self, parent, zone, message) {
           printMessages.writeln();
           printMessages.write(message);
         }));
@@ -39,7 +39,7 @@
         // In case they forget to set this.
         response.exitCode ??= EXIT_CODE_OK;
       } catch (e, s) {
-        response = new WorkResponse()
+        response = WorkResponse()
           ..exitCode = EXIT_CODE_ERROR
           ..output = '$e\n$s';
       }
diff --git a/lib/src/worker/worker_connection.dart b/lib/src/worker/worker_connection.dart
index c55f52d..6e072a3 100644
--- a/lib/src/worker/worker_connection.dart
+++ b/lib/src/worker/worker_connection.dart
@@ -34,9 +34,9 @@
           StreamSink<List<int>> outputStream,
           SendPort sendPort}) =>
       sendPort == null
-          ? new StdAsyncWorkerConnection(
+          ? StdAsyncWorkerConnection(
               inputStream: inputStream, outputStream: outputStream)
-          : new SendPortAsyncWorkerConnection(sendPort);
+          : SendPortAsyncWorkerConnection(sendPort);
 
   @override
   Future<WorkRequest> readRequest();
@@ -54,7 +54,7 @@
 
   StdAsyncWorkerConnection(
       {Stream<List<int>> inputStream, StreamSink<List<int>> outputStream})
-      : _messageGrouper = new AsyncMessageGrouper(inputStream ?? stdin),
+      : _messageGrouper = AsyncMessageGrouper(inputStream ?? stdin),
         _outputStream = outputStream ?? stdout;
 
   @override
@@ -62,7 +62,7 @@
     var buffer = await _messageGrouper.next;
     if (buffer == null) return null;
 
-    return new WorkRequest.fromBuffer(buffer);
+    return WorkRequest.fromBuffer(buffer);
   }
 
   @override
@@ -78,18 +78,18 @@
   final SendPort sendPort;
 
   factory SendPortAsyncWorkerConnection(SendPort sendPort) {
-    var receivePort = new ReceivePort();
+    var receivePort = ReceivePort();
     sendPort.send(receivePort.sendPort);
     return SendPortAsyncWorkerConnection._(receivePort, sendPort);
   }
 
   SendPortAsyncWorkerConnection._(this.receivePort, this.sendPort)
-      : receivePortIterator = new StreamIterator(receivePort.cast());
+      : receivePortIterator = StreamIterator(receivePort.cast());
 
   @override
   Future<WorkRequest> readRequest() async {
     if (!await receivePortIterator.moveNext()) return null;
-    return new WorkRequest.fromBuffer(receivePortIterator.current);
+    return WorkRequest.fromBuffer(receivePortIterator.current);
   }
 
   @override
@@ -105,7 +105,7 @@
   final Stdout _stdoutStream;
 
   StdSyncWorkerConnection({Stdin stdinStream, Stdout stdoutStream})
-      : _messageGrouper = new SyncMessageGrouper(stdinStream ?? stdin),
+      : _messageGrouper = SyncMessageGrouper(stdinStream ?? stdin),
         _stdoutStream = stdoutStream ?? stdout;
 
   @override
@@ -113,7 +113,7 @@
     var buffer = _messageGrouper.next;
     if (buffer == null) return null;
 
-    return new WorkRequest.fromBuffer(buffer);
+    return WorkRequest.fromBuffer(buffer);
   }
 
   @override
diff --git a/lib/testing.dart b/lib/testing.dart
index 1e7ccc3..08e6bd0 100644
--- a/lib/testing.dart
+++ b/lib/testing.dart
@@ -23,7 +23,7 @@
 /// A [Stdin] mock object which only implements `readByteSync`.
 class TestStdinSync implements TestStdin {
   /// Pending bytes to be delivered synchronously.
-  final Queue<int> pendingBytes = new Queue<int>();
+  final Queue<int> pendingBytes = Queue<int>();
 
   /// Adds all the [bytes] to this stream.
   void addInputBytes(List<int> bytes) {
@@ -42,7 +42,7 @@
 
   @override
   void noSuchMethod(Invocation invocation) {
-    throw new StateError('Unexpected invocation ${invocation.memberName}.');
+    throw StateError('Unexpected invocation ${invocation.memberName}.');
   }
 }
 
@@ -51,7 +51,7 @@
 /// Note: You must call [close] in order for the loop to exit properly.
 class TestStdinAsync implements TestStdin {
   /// Controls the stream for async delivery of bytes.
-  final StreamController<Uint8List> _controller = new StreamController();
+  final StreamController<Uint8List> _controller = StreamController();
   StreamController<Uint8List> get controller => _controller;
 
   /// Adds all the [bytes] to this stream.
@@ -73,7 +73,7 @@
 
   @override
   void noSuchMethod(Invocation invocation) {
-    throw new StateError('Unexpected invocation ${invocation.memberName}.');
+    throw StateError('Unexpected invocation ${invocation.memberName}.');
   }
 }
 
@@ -88,7 +88,7 @@
 
   @override
   void noSuchMethod(Invocation invocation) {
-    throw new StateError('Unexpected invocation ${invocation.memberName}.');
+    throw StateError('Unexpected invocation ${invocation.memberName}.');
   }
 }
 
@@ -123,7 +123,7 @@
 /// A [SyncWorkerLoop] for testing.
 class TestSyncWorkerLoop extends SyncWorkerLoop implements TestWorkerLoop {
   final List<WorkRequest> requests = <WorkRequest>[];
-  final Queue<WorkResponse> _responses = new Queue<WorkResponse>();
+  final Queue<WorkResponse> _responses = Queue<WorkResponse>();
 
   @override
   final String printMessage;
@@ -165,7 +165,7 @@
 /// A [AsyncWorkerLoop] for testing.
 class TestAsyncWorkerLoop extends AsyncWorkerLoop implements TestWorkerLoop {
   final List<WorkRequest> requests = <WorkRequest>[];
-  final Queue<WorkResponse> _responses = new Queue<WorkResponse>();
+  final Queue<WorkResponse> _responses = Queue<WorkResponse>();
 
   @override
   final String printMessage;
diff --git a/pubspec.yaml b/pubspec.yaml
index bc7edf1..1d63f92 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -10,7 +10,8 @@
 
 dependencies:
   async: '>1.9.0 <3.0.0'
-  protobuf: ^0.14.0
+  pedantic: ^1.8.0
+  protobuf: '>=0.14.0 <2.0.0'
 
 dev_dependencies:
   test: ^1.2.0
diff --git a/test/driver_test.dart b/test/driver_test.dart
index 9b664e9..8318e51 100644
--- a/test/driver_test.dart
+++ b/test/driver_test.dart
@@ -24,7 +24,7 @@
         () async {
       int maxWorkers = 4;
       int maxIdleWorkers = 2;
-      driver = new BazelWorkerDriver(MockWorker.spawn,
+      driver = BazelWorkerDriver(MockWorker.spawn,
           maxWorkers: maxWorkers, maxIdleWorkers: maxIdleWorkers);
       for (int i = 0; i < 10; i++) {
         await _doRequests(driver: driver);
@@ -39,7 +39,7 @@
     test('can run multiple requests through one worker', () async {
       int maxWorkers = 1;
       int maxIdleWorkers = 1;
-      driver = new BazelWorkerDriver(MockWorker.spawn,
+      driver = BazelWorkerDriver(MockWorker.spawn,
           maxWorkers: maxWorkers, maxIdleWorkers: maxIdleWorkers);
       for (int i = 0; i < 10; i++) {
         await _doRequests(driver: driver);
@@ -49,8 +49,8 @@
     });
 
     test('can run one request through multiple workers', () async {
-      driver = new BazelWorkerDriver(MockWorker.spawn,
-          maxWorkers: 4, maxIdleWorkers: 4);
+      driver =
+          BazelWorkerDriver(MockWorker.spawn, maxWorkers: 4, maxIdleWorkers: 4);
       for (int i = 0; i < 10; i++) {
         await _doRequests(driver: driver, count: 1);
         expect(MockWorker.liveWorkers.length, 1);
@@ -60,7 +60,7 @@
 
     test('can run with maxIdleWorkers == 0', () async {
       int maxWorkers = 4;
-      driver = new BazelWorkerDriver(MockWorker.spawn,
+      driver = BazelWorkerDriver(MockWorker.spawn,
           maxWorkers: maxWorkers, maxIdleWorkers: 0);
       for (int i = 0; i < 10; i++) {
         await _doRequests(driver: driver);
@@ -71,14 +71,17 @@
 
     test('trackWork gets invoked when a worker is actually ready', () async {
       var maxWorkers = 2;
-      driver = new BazelWorkerDriver(MockWorker.spawn, maxWorkers: maxWorkers);
+      driver = BazelWorkerDriver(MockWorker.spawn, maxWorkers: maxWorkers);
       var tracking = <Future>[];
-      await _doRequests(driver: driver, count: 10, trackWork: (Future response) {
-          // We should never be tracking more than `maxWorkers` jobs at a time.
-          expect(tracking.length, lessThan(maxWorkers));
-          tracking.add(response);
-          response.then((_) => tracking.remove(response));
-        });
+      await _doRequests(
+          driver: driver,
+          count: 10,
+          trackWork: (Future response) {
+            // We should never be tracking more than `maxWorkers` jobs at a time.
+            expect(tracking.length, lessThan(maxWorkers));
+            tracking.add(response);
+            response.then((_) => tracking.remove(response));
+          });
     });
 
     group('failing workers', () {
@@ -86,17 +89,17 @@
       /// ones after that, and which will retry [maxRetries] times.
       void createDriver({int maxRetries = 2, int numBadWorkers = 2}) {
         int numSpawned = 0;
-        driver = new BazelWorkerDriver(
-            () async => new MockWorker(workerLoopFactory: (MockWorker worker) {
-                  var connection = new StdAsyncWorkerConnection(
+        driver = BazelWorkerDriver(
+            () async => MockWorker(workerLoopFactory: (MockWorker worker) {
+                  var connection = StdAsyncWorkerConnection(
                       inputStream: worker._stdinController.stream,
                       outputStream: worker._stdoutController.sink);
                   if (numSpawned < numBadWorkers) {
                     numSpawned++;
-                    return new ThrowingMockWorkerLoop(
+                    return ThrowingMockWorkerLoop(
                         worker, MockWorker.responseQueue, connection);
                   } else {
-                    return new MockWorkerLoop(MockWorker.responseQueue,
+                    return MockWorkerLoop(MockWorker.responseQueue,
                         connection: connection);
                   }
                 }),
@@ -105,9 +108,9 @@
 
       test('should retry up to maxRetries times', () async {
         createDriver();
-        var expectedResponse = new WorkResponse();
+        var expectedResponse = WorkResponse();
         MockWorker.responseQueue.addAll([null, null, expectedResponse]);
-        var actualResponse = await driver.doWork(new WorkRequest());
+        var actualResponse = await driver.doWork(WorkRequest());
         // The first 2 null responses are thrown away, and we should get the
         // third one.
         expect(actualResponse, expectedResponse);
@@ -118,8 +121,8 @@
 
       test('should fail if it exceeds maxRetries failures', () async {
         createDriver(maxRetries: 2, numBadWorkers: 3);
-        MockWorker.responseQueue.addAll([null, null, new WorkResponse()]);
-        var actualResponse = await driver.doWork(new WorkRequest());
+        MockWorker.responseQueue.addAll([null, null, WorkResponse()]);
+        var actualResponse = await driver.doWork(WorkRequest());
         // Should actually get a bad response.
         expect(actualResponse.exitCode, 15);
         expect(
@@ -148,11 +151,11 @@
     Function(Future<WorkResponse>) trackWork}) async {
   // If we create a driver, we need to make sure and terminate it.
   var terminateDriver = driver == null;
-  driver ??= new BazelWorkerDriver(MockWorker.spawn);
+  driver ??= BazelWorkerDriver(MockWorker.spawn);
   count ??= 100;
   terminateDriver ??= true;
-  var requests = new List.generate(count, (_) => new WorkRequest());
-  var responses = new List.generate(count, (_) => new WorkResponse());
+  var requests = List.generate(count, (_) => WorkRequest());
+  var responses = List.generate(count, (_) => WorkResponse());
   MockWorker.responseQueue.addAll(responses);
   var actualResponses = await Future.wait(
       requests.map((request) => driver.doWork(request, trackWork: trackWork)));
@@ -179,9 +182,7 @@
 class ThrowingMockWorkerLoop extends MockWorkerLoop {
   final MockWorker _mockWorker;
 
-  ThrowingMockWorkerLoop(
-      this._mockWorker,
-      Queue<WorkResponse> responseQueue,
+  ThrowingMockWorkerLoop(this._mockWorker, Queue<WorkResponse> responseQueue,
       AsyncWorkerConnection connection)
       : super(responseQueue, connection: connection);
 
@@ -205,7 +206,7 @@
 /// If there are no items left in [responseQueue] then it will throw.
 class MockWorker implements Process {
   /// Spawns a new [MockWorker].
-  static Future<MockWorker> spawn() async => new MockWorker();
+  static Future<MockWorker> spawn() async => MockWorker();
 
   /// Worker loop that handles reading requests and responding.
   AsyncWorkerLoop _workerLoop;
@@ -213,7 +214,7 @@
   /// Static queue of pending responses, these are shared by all workers.
   ///
   /// If this is empty and a request is received then it will throw.
-  static final responseQueue = new Queue<WorkResponse>();
+  static final responseQueue = Queue<WorkResponse>();
 
   /// Static list of all live workers.
   static final liveWorkers = <MockWorker>[];
@@ -226,37 +227,37 @@
     liveWorkers.add(this);
     var workerLoop = workerLoopFactory != null
         ? workerLoopFactory(this)
-        : new MockWorkerLoop(responseQueue,
-            connection: new StdAsyncWorkerConnection(
+        : MockWorkerLoop(responseQueue,
+            connection: StdAsyncWorkerConnection(
                 inputStream: this._stdinController.stream,
                 outputStream: this._stdoutController.sink));
     _workerLoop = workerLoop..run();
   }
 
   Future<int> get exitCode => _exitCodeCompleter.future;
-  final _exitCodeCompleter = new Completer<int>();
+  final _exitCodeCompleter = Completer<int>();
 
   @override
   Stream<List<int>> get stdout => _stdoutController.stream;
-  final _stdoutController = new StreamController<List<int>>();
+  final _stdoutController = StreamController<List<int>>();
 
   @override
   Stream<List<int>> get stderr => _stderrController.stream;
-  final _stderrController = new StreamController<List<int>>();
+  final _stderrController = StreamController<List<int>>();
 
   @override
   IOSink get stdin {
-    _stdin ??= new IOSink(_stdinController.sink);
+    _stdin ??= IOSink(_stdinController.sink);
     return _stdin;
   }
 
   IOSink _stdin;
-  final _stdinController = new StreamController<List<int>>();
+  final _stdinController = StreamController<List<int>>();
 
-  int get pid => throw new UnsupportedError('Not needed.');
+  int get pid => throw UnsupportedError('Not needed.');
 
   @override
-  bool kill([ProcessSignal = ProcessSignal.sigterm, int exitCode = 0]) {
+  bool kill([processSignal = ProcessSignal.sigterm, int exitCode = 0]) {
     if (_killed) return false;
     () async {
       await _stdoutController.close();
diff --git a/test/message_grouper_test.dart b/test/message_grouper_test.dart
index 39dcb9e..7ce26fa 100644
--- a/test/message_grouper_test.dart
+++ b/test/message_grouper_test.dart
@@ -14,13 +14,13 @@
 
 void main() {
   group('AsyncMessageGrouper', () {
-    runTests(() => new TestStdinAsync(),
-        (Stdin stdinStream) => new AsyncMessageGrouper(stdinStream));
+    runTests(() => TestStdinAsync(),
+        (Stdin stdinStream) => AsyncMessageGrouper(stdinStream));
   });
 
   group('SyncMessageGrouper', () {
-    runTests(() => new TestStdinSync(),
-        (Stdin stdinStream) => new SyncMessageGrouper(stdinStream));
+    runTests(() => TestStdinSync(),
+        (Stdin stdinStream) => SyncMessageGrouper(stdinStream));
   });
 }
 
diff --git a/test/worker_loop_test.dart b/test/worker_loop_test.dart
index 2356060..fd2fcff 100644
--- a/test/worker_loop_test.dart
+++ b/test/worker_loop_test.dart
@@ -13,38 +13,38 @@
 void main() {
   group('SyncWorkerLoop', () {
     runTests(
-        () => new TestStdinSync(),
+        () => TestStdinSync(),
         (Stdin stdinStream, Stdout stdoutStream) =>
-            new TestSyncWorkerConnection(stdinStream, stdoutStream),
+            TestSyncWorkerConnection(stdinStream, stdoutStream),
         (TestSyncWorkerConnection connection) =>
-            new TestSyncWorkerLoop(connection));
+            TestSyncWorkerLoop(connection));
   });
 
   group('AsyncWorkerLoop', () {
     runTests(
-        () => new TestStdinAsync(),
+        () => TestStdinAsync(),
         (Stdin stdinStream, Stdout stdoutStream) =>
-            new TestAsyncWorkerConnection(stdinStream, stdoutStream),
+            TestAsyncWorkerConnection(stdinStream, stdoutStream),
         (TestAsyncWorkerConnection connection) =>
-            new TestAsyncWorkerLoop(connection));
+            TestAsyncWorkerLoop(connection));
   });
 
   group('SyncWorkerLoopWithPrint', () {
     runTests(
-        () => new TestStdinSync(),
+        () => TestStdinSync(),
         (Stdin stdinStream, Stdout stdoutStream) =>
-            new TestSyncWorkerConnection(stdinStream, stdoutStream),
+            TestSyncWorkerConnection(stdinStream, stdoutStream),
         (TestSyncWorkerConnection connection) =>
-            new TestSyncWorkerLoop(connection, printMessage: 'Goodbye!'));
+            TestSyncWorkerLoop(connection, printMessage: 'Goodbye!'));
   });
 
   group('AsyncWorkerLoopWithPrint', () {
     runTests(
-        () => new TestStdinAsync(),
+        () => TestStdinAsync(),
         (Stdin stdinStream, Stdout stdoutStream) =>
-            new TestAsyncWorkerConnection(stdinStream, stdoutStream),
+            TestAsyncWorkerConnection(stdinStream, stdoutStream),
         (TestAsyncWorkerConnection connection) =>
-            new TestAsyncWorkerLoop(connection, printMessage: 'Goodbye!'));
+            TestAsyncWorkerLoop(connection, printMessage: 'Goodbye!'));
   });
 }
 
@@ -59,24 +59,24 @@
 
   setUp(() {
     stdinStream = stdinFactory();
-    stdoutStream = new TestStdoutStream();
+    stdoutStream = TestStdoutStream();
     connection = workerConnectionFactory(stdinStream, stdoutStream);
     workerLoop = workerLoopFactory(connection);
   });
 
   test('basic', () async {
-    var request = new WorkRequest();
+    var request = WorkRequest();
     request.arguments.addAll(['--foo=bar']);
     stdinStream.addInputBytes(protoToDelimitedBuffer(request));
     stdinStream.close();
 
-    var response = new WorkResponse()..output = 'Hello World';
+    var response = WorkResponse()..output = 'Hello World';
     workerLoop.enqueueResponse(response);
 
     // Make sure `print` never gets called in the parent zone.
     var printMessages = <String>[];
     await runZoned(() => workerLoop.run(), zoneSpecification:
-        new ZoneSpecification(print: (self, parent, zone, message) {
+        ZoneSpecification(print: (self, parent, zone, message) {
       printMessages.add(message);
     }));
     expect(printMessages, isEmpty,
@@ -96,7 +96,7 @@
   });
 
   test('Exception in the worker.', () async {
-    var request = new WorkRequest();
+    var request = WorkRequest();
     request.arguments.addAll(['--foo=bar']);
     stdinStream.addInputBytes(protoToDelimitedBuffer(request));
     stdinStream.close();
@@ -125,7 +125,7 @@
       (stdinStream as TestStdinSync).pendingBytes.clear();
       await workerLoop.run();
     } else if (stdinStream is TestStdinAsync) {
-      var done = new Completer();
+      var done = Completer();
       workerLoop.run().then((_) => done.complete(null));
       (stdinStream as TestStdinAsync).controller.addError('Error!!');
       await done.future;