diff --git a/analysis_options.yaml b/analysis_options.yaml
new file mode 100644
index 0000000..749f62a
--- /dev/null
+++ b/analysis_options.yaml
@@ -0,0 +1,11 @@
+include: package:pedantic/analysis_options.yaml
+analyzer:
+  strong-mode:
+    implicit-casts: false
+linter:
+  rules:
+    - await_only_futures
+    - implementation_imports
+    - prefer_typing_uninitialized_variables
+    - unnecessary_const
+    - unnecessary_new
diff --git a/lib/pool.dart b/lib/pool.dart
index ea3d2f0..416b14b 100644
--- a/lib/pool.dart
+++ b/lib/pool.dart
@@ -21,20 +21,20 @@
   ///
   /// When an item is released, the next element of [_requestedResources] will
   /// be completed.
-  final _requestedResources = new Queue<Completer<PoolResource>>();
+  final _requestedResources = Queue<Completer<PoolResource>>();
 
   /// Callbacks that must be called before additional resources can be
   /// allocated.
   ///
   /// See [PoolResource.allowRelease].
-  final _onReleaseCallbacks = new Queue<Function>();
+  final _onReleaseCallbacks = Queue<void Function()>();
 
   /// Completers that will be completed once `onRelease` callbacks are done
   /// running.
   ///
   /// These are kept in a queue to ensure that the earliest request completes
   /// first regardless of what order the `onRelease` callbacks complete in.
-  final _onReleaseCompleters = new Queue<Completer<PoolResource>>();
+  final _onReleaseCompleters = Queue<Completer<PoolResource>>();
 
   /// The maximum number of resources that may be allocated at once.
   final int _maxAllocatedResources;
@@ -82,7 +82,7 @@
     if (timeout != null) {
       // Start the timer canceled since we only want to start counting down once
       // we've run out of available resources.
-      _timer = new RestartableTimer(timeout, _onTimeout)..cancel();
+      _timer = RestartableTimer(timeout, _onTimeout)..cancel();
     }
   }
 
@@ -92,16 +92,16 @@
   /// until one of them is released.
   Future<PoolResource> request() {
     if (isClosed) {
-      throw new StateError("request() may not be called on a closed Pool.");
+      throw StateError("request() may not be called on a closed Pool.");
     }
 
     if (_allocatedResources < _maxAllocatedResources) {
       _allocatedResources++;
-      return new Future.value(new PoolResource._(this));
+      return Future.value(PoolResource._(this));
     } else if (_onReleaseCallbacks.isNotEmpty) {
       return _runOnRelease(_onReleaseCallbacks.removeFirst());
     } else {
-      var completer = new Completer<PoolResource>();
+      var completer = Completer<PoolResource>();
       _requestedResources.add(completer);
       _resetTimer();
       return completer.future;
@@ -114,8 +114,7 @@
   /// The return value of [callback] is piped to the returned Future.
   Future<T> withResource<T>(FutureOr<T> callback()) {
     if (isClosed) {
-      throw new StateError(
-          "withResource() may not be called on a closed Pool.");
+      throw StateError("withResource() may not be called on a closed Pool.");
     }
 
     // We can't use async/await here because we need to start the request
@@ -123,7 +122,7 @@
     // functions have an asynchronous gap between calling and running the body,
     // and [close] could be called during that gap. See #3.
     return request().then((resource) {
-      return new Future<T>.sync(callback).whenComplete(resource.release);
+      return Future<T>.sync(callback).whenComplete(resource.release);
     });
   }
 
@@ -143,9 +142,9 @@
 
         _resetTimer();
 
-        _closeGroup = new FutureGroup();
+        _closeGroup = FutureGroup();
         for (var callback in _onReleaseCallbacks) {
-          _closeGroup.add(new Future.sync(callback));
+          _closeGroup.add(Future.sync(callback));
         }
 
         _allocatedResources -= _onReleaseCallbacks.length;
@@ -154,7 +153,7 @@
         if (_allocatedResources == 0) _closeGroup.close();
         return _closeGroup.future;
       });
-  final _closeMemo = new AsyncMemoizer();
+  final _closeMemo = AsyncMemoizer();
 
   /// If there are any pending requests, this will fire the oldest one.
   void _onResourceReleased() {
@@ -162,7 +161,7 @@
 
     if (_requestedResources.isNotEmpty) {
       var pending = _requestedResources.removeFirst();
-      pending.complete(new PoolResource._(this));
+      pending.complete(PoolResource._(this));
     } else {
       _allocatedResources--;
       if (isClosed && _allocatedResources == 0) _closeGroup.close();
@@ -178,7 +177,7 @@
       var pending = _requestedResources.removeFirst();
       pending.complete(_runOnRelease(onRelease));
     } else if (isClosed) {
-      _closeGroup.add(new Future.sync(onRelease));
+      _closeGroup.add(Future.sync(onRelease));
       _allocatedResources--;
       if (_allocatedResources == 0) _closeGroup.close();
     } else {
@@ -194,13 +193,13 @@
   /// Futures returned by [_runOnRelease] always complete in the order they were
   /// created, even if earlier [onRelease] callbacks take longer to run.
   Future<PoolResource> _runOnRelease(onRelease()) {
-    new Future.sync(onRelease).then((value) {
-      _onReleaseCompleters.removeFirst().complete(new PoolResource._(this));
-    }).catchError((error, stackTrace) {
+    Future.sync(onRelease).then((value) {
+      _onReleaseCompleters.removeFirst().complete(PoolResource._(this));
+    }).catchError((error, StackTrace stackTrace) {
       _onReleaseCompleters.removeFirst().completeError(error, stackTrace);
     });
 
-    var completer = new Completer<PoolResource>.sync();
+    var completer = Completer<PoolResource>.sync();
     _onReleaseCompleters.add(completer);
     return completer.future;
   }
@@ -221,11 +220,11 @@
   void _onTimeout() {
     for (var completer in _requestedResources) {
       completer.completeError(
-          new TimeoutException(
+          TimeoutException(
               "Pool deadlock: all resources have been "
               "allocated for too long.",
               _timeout),
-          new Chain.current());
+          Chain.current());
     }
     _requestedResources.clear();
     _timer = null;
@@ -248,7 +247,7 @@
   /// no longer allocated, and that a new [PoolResource] may be allocated.
   void release() {
     if (_released) {
-      throw new StateError("A PoolResource may only be released once.");
+      throw StateError("A PoolResource may only be released once.");
     }
     _released = true;
     _pool._onResourceReleased();
@@ -268,7 +267,7 @@
   /// may be complete, but it could still emit asynchronous errors.
   void allowRelease(onRelease()) {
     if (_released) {
-      throw new StateError("A PoolResource may only be released once.");
+      throw StateError("A PoolResource may only be released once.");
     }
     _released = true;
     _pool._onResourceReleaseAllowed(onRelease);
diff --git a/pubspec.yaml b/pubspec.yaml
index 84b97b2..a709842 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: pool
-version: 1.3.6
+version: 1.3.7-dev
 
 description: A class for managing a finite pool of resources.
 author: Dart Team <misc@dartlang.org>
@@ -14,4 +14,5 @@
 
 dev_dependencies:
   fake_async: ^1.0.0
+  pedantic: ^1.4.0
   test: ^1.0.0
diff --git a/test/pool_test.dart b/test/pool_test.dart
index cb0dd30..a156c52 100644
--- a/test/pool_test.dart
+++ b/test/pool_test.dart
@@ -5,6 +5,7 @@
 import 'dart:async';
 
 import 'package:fake_async/fake_async.dart';
+import 'package:pedantic/pedantic.dart';
 import 'package:pool/pool.dart';
 import 'package:stack_trace/stack_trace.dart';
 import 'package:test/test.dart';
@@ -12,27 +13,27 @@
 void main() {
   group("request()", () {
     test("resources can be requested freely up to the limit", () {
-      var pool = new Pool(50);
+      var pool = Pool(50);
       for (var i = 0; i < 50; i++) {
         expect(pool.request(), completes);
       }
     });
 
     test("resources block past the limit", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50);
+      FakeAsync().run((async) {
+        var pool = Pool(50);
         for (var i = 0; i < 50; i++) {
           expect(pool.request(), completes);
         }
         expect(pool.request(), doesNotComplete);
 
-        async.elapse(new Duration(seconds: 1));
+        async.elapse(Duration(seconds: 1));
       });
     });
 
     test("a blocked resource is allocated when another is released", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50);
+      FakeAsync().run((async) {
+        var pool = Pool(50);
         for (var i = 0; i < 49; i++) {
           expect(pool.request(), completes);
         }
@@ -41,85 +42,85 @@
           // This will only complete once [lastAllocatedResource] is released.
           expect(pool.request(), completes);
 
-          new Future.delayed(new Duration(microseconds: 1)).then((_) {
+          Future.delayed(Duration(microseconds: 1)).then((_) {
             lastAllocatedResource.release();
           });
         });
 
-        async.elapse(new Duration(seconds: 1));
+        async.elapse(Duration(seconds: 1));
       });
     });
   });
 
   group("withResource()", () {
     test("can be called freely up to the limit", () {
-      var pool = new Pool(50);
+      var pool = Pool(50);
       for (var i = 0; i < 50; i++) {
-        pool.withResource(expectAsync0(() => new Completer().future));
+        pool.withResource(expectAsync0(() => Completer().future));
       }
     });
 
     test("blocks the callback past the limit", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50);
+      FakeAsync().run((async) {
+        var pool = Pool(50);
         for (var i = 0; i < 50; i++) {
-          pool.withResource(expectAsync0(() => new Completer().future));
+          pool.withResource(expectAsync0(() => Completer().future));
         }
         pool.withResource(expectNoAsync());
 
-        async.elapse(new Duration(seconds: 1));
+        async.elapse(Duration(seconds: 1));
       });
     });
 
     test("a blocked resource is allocated when another is released", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50);
+      FakeAsync().run((async) {
+        var pool = Pool(50);
         for (var i = 0; i < 49; i++) {
-          pool.withResource(expectAsync0(() => new Completer().future));
+          pool.withResource(expectAsync0(() => Completer().future));
         }
 
-        var completer = new Completer();
+        var completer = Completer();
         pool.withResource(() => completer.future);
         var blockedResourceAllocated = false;
         pool.withResource(() {
           blockedResourceAllocated = true;
         });
 
-        new Future.delayed(new Duration(microseconds: 1)).then((_) {
+        Future.delayed(Duration(microseconds: 1)).then((_) {
           expect(blockedResourceAllocated, isFalse);
           completer.complete();
-          return new Future.delayed(new Duration(microseconds: 1));
+          return Future.delayed(Duration(microseconds: 1));
         }).then((_) {
           expect(blockedResourceAllocated, isTrue);
         });
 
-        async.elapse(new Duration(seconds: 1));
+        async.elapse(Duration(seconds: 1));
       });
     });
 
     // Regression test for #3.
     test("can be called immediately before close()", () async {
-      var pool = new Pool(1);
-      pool.withResource(expectAsync0(() {}));
+      var pool = Pool(1);
+      unawaited(pool.withResource(expectAsync0(() {})));
       await pool.close();
     });
   });
 
   group("with a timeout", () {
     test("doesn't time out if there are no pending requests", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50, timeout: new Duration(seconds: 5));
+      FakeAsync().run((async) {
+        var pool = Pool(50, timeout: Duration(seconds: 5));
         for (var i = 0; i < 50; i++) {
           expect(pool.request(), completes);
         }
 
-        async.elapse(new Duration(seconds: 6));
+        async.elapse(Duration(seconds: 6));
       });
     });
 
     test("resets the timer if a resource is returned", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50, timeout: new Duration(seconds: 5));
+      FakeAsync().run((async) {
+        var pool = Pool(50, timeout: Duration(seconds: 5));
         for (var i = 0; i < 49; i++) {
           expect(pool.request(), completes);
         }
@@ -128,48 +129,48 @@
           // This will only complete once [lastAllocatedResource] is released.
           expect(pool.request(), completes);
 
-          new Future.delayed(new Duration(seconds: 3)).then((_) {
+          Future.delayed(Duration(seconds: 3)).then((_) {
             lastAllocatedResource.release();
             expect(pool.request(), doesNotComplete);
           });
         });
 
-        async.elapse(new Duration(seconds: 6));
+        async.elapse(Duration(seconds: 6));
       });
     });
 
     test("resets the timer if a resource is requested", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50, timeout: new Duration(seconds: 5));
+      FakeAsync().run((async) {
+        var pool = Pool(50, timeout: Duration(seconds: 5));
         for (var i = 0; i < 50; i++) {
           expect(pool.request(), completes);
         }
         expect(pool.request(), doesNotComplete);
 
-        new Future.delayed(new Duration(seconds: 3)).then((_) {
+        Future.delayed(Duration(seconds: 3)).then((_) {
           expect(pool.request(), doesNotComplete);
         });
 
-        async.elapse(new Duration(seconds: 6));
+        async.elapse(Duration(seconds: 6));
       });
     });
 
     test("times out if nothing happens", () {
-      new FakeAsync().run((async) {
-        var pool = new Pool(50, timeout: new Duration(seconds: 5));
+      FakeAsync().run((async) {
+        var pool = Pool(50, timeout: Duration(seconds: 5));
         for (var i = 0; i < 50; i++) {
           expect(pool.request(), completes);
         }
-        expect(pool.request(), throwsA(new TypeMatcher<TimeoutException>()));
+        expect(pool.request(), throwsA(TypeMatcher<TimeoutException>()));
 
-        async.elapse(new Duration(seconds: 6));
+        async.elapse(Duration(seconds: 6));
       });
     });
   });
 
   group("allowRelease()", () {
     test("runs the callback once the resource limit is exceeded", () async {
-      var pool = new Pool(50);
+      var pool = Pool(50);
       for (var i = 0; i < 49; i++) {
         expect(pool.request(), completes);
       }
@@ -177,17 +178,17 @@
       var resource = await pool.request();
       var onReleaseCalled = false;
       resource.allowRelease(() => onReleaseCalled = true);
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(onReleaseCalled, isFalse);
 
       expect(pool.request(), completes);
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(onReleaseCalled, isTrue);
     });
 
     test("runs the callback immediately if there are blocked requests",
         () async {
-      var pool = new Pool(1);
+      var pool = Pool(1);
       var resource = await pool.request();
 
       // This will be blocked until [resource.allowRelease] is called.
@@ -195,54 +196,54 @@
 
       var onReleaseCalled = false;
       resource.allowRelease(() => onReleaseCalled = true);
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(onReleaseCalled, isTrue);
     });
 
     test("blocks the request until the callback completes", () async {
-      var pool = new Pool(1);
+      var pool = Pool(1);
       var resource = await pool.request();
 
       var requestComplete = false;
-      pool.request().then((_) => requestComplete = true);
+      unawaited(pool.request().then((_) => requestComplete = true));
 
-      var completer = new Completer();
+      var completer = Completer();
       resource.allowRelease(() => completer.future);
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(requestComplete, isFalse);
 
       completer.complete();
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(requestComplete, isTrue);
     });
 
     test("completes requests in request order regardless of callback order",
         () async {
-      var pool = new Pool(2);
+      var pool = Pool(2);
       var resource1 = await pool.request();
       var resource2 = await pool.request();
 
       var request1Complete = false;
-      pool.request().then((_) => request1Complete = true);
+      unawaited(pool.request().then((_) => request1Complete = true));
       var request2Complete = false;
-      pool.request().then((_) => request2Complete = true);
+      unawaited(pool.request().then((_) => request2Complete = true));
 
       var onRelease1Called = false;
-      var completer1 = new Completer();
+      var completer1 = Completer();
       resource1.allowRelease(() {
         onRelease1Called = true;
         return completer1.future;
       });
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(onRelease1Called, isTrue);
 
       var onRelease2Called = false;
-      var completer2 = new Completer();
+      var completer2 = Completer();
       resource2.allowRelease(() {
         onRelease2Called = true;
         return completer2.future;
       });
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(onRelease2Called, isTrue);
       expect(request1Complete, isFalse);
       expect(request2Complete, isFalse);
@@ -251,18 +252,18 @@
       // was triggered by the second blocking request, it should complete the
       // first one to preserve ordering.
       completer2.complete();
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(request1Complete, isTrue);
       expect(request2Complete, isFalse);
 
       completer1.complete();
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       expect(request1Complete, isTrue);
       expect(request2Complete, isTrue);
     });
 
     test("runs onRequest in the zone it was created", () async {
-      var pool = new Pool(1);
+      var pool = Pool(1);
       var resource = await pool.request();
 
       var outerZone = Zone.current;
@@ -275,29 +276,29 @@
         }));
       });
 
-      pool.request();
+      await pool.request();
     });
   });
 
   test("done doesn't complete without close", () async {
-    var pool = new Pool(1);
-    pool.done.then(expectAsync1((_) {}, count: 0));
+    var pool = Pool(1);
+    unawaited(pool.done.then(expectAsync1((_) {}, count: 0)));
 
     var resource = await pool.request();
     resource.release();
 
-    await new Future.delayed(Duration.zero);
+    await Future.delayed(Duration.zero);
   });
 
   group("close()", () {
     test("disallows request() and withResource()", () {
-      var pool = new Pool(1)..close();
+      var pool = Pool(1)..close();
       expect(pool.request, throwsStateError);
       expect(() => pool.withResource(() {}), throwsStateError);
     });
 
     test("pending requests are fulfilled", () async {
-      var pool = new Pool(1);
+      var pool = Pool(1);
       var resource1 = await pool.request();
       expect(
           pool.request().then((resource2) {
@@ -310,10 +311,10 @@
     });
 
     test("pending requests are fulfilled with allowRelease", () async {
-      var pool = new Pool(1);
+      var pool = Pool(1);
       var resource1 = await pool.request();
 
-      var completer = new Completer();
+      var completer = Completer();
       expect(
           pool.request().then((resource2) {
             expect(completer.isCompleted, isTrue);
@@ -323,13 +324,13 @@
       expect(pool.close(), completes);
 
       resource1.allowRelease(() => completer.future);
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
 
       completer.complete();
     });
 
     test("doesn't complete until all resources are released", () async {
-      var pool = new Pool(2);
+      var pool = Pool(2);
       var resource1 = await pool.request();
       var resource2 = await pool.request();
       var resource3Future = pool.request();
@@ -347,11 +348,11 @@
 
       resource1Released = true;
       resource1.release();
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
 
       resource2Released = true;
       resource2.release();
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
 
       var resource3 = await resource3Future;
       resource3Released = true;
@@ -359,12 +360,12 @@
     });
 
     test("active onReleases complete as usual", () async {
-      var pool = new Pool(1);
+      var pool = Pool(1);
       var resource = await pool.request();
 
       // Set up an onRelease callback whose completion is controlled by
       // [completer].
-      var completer = new Completer();
+      var completer = Completer();
       resource.allowRelease(() => completer.future);
       expect(
           pool.request().then((_) {
@@ -372,21 +373,21 @@
           }),
           completes);
 
-      await new Future.delayed(Duration.zero);
-      pool.close();
+      await Future.delayed(Duration.zero);
+      unawaited(pool.close());
 
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       completer.complete();
     });
 
     test("inactive onReleases fire", () async {
-      var pool = new Pool(2);
+      var pool = Pool(2);
       var resource1 = await pool.request();
       var resource2 = await pool.request();
 
-      var completer1 = new Completer();
+      var completer1 = Completer();
       resource1.allowRelease(() => completer1.future);
-      var completer2 = new Completer();
+      var completer2 = Completer();
       resource2.allowRelease(() => completer2.future);
 
       expect(
@@ -396,42 +397,42 @@
           }),
           completes);
 
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       completer1.complete();
 
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       completer2.complete();
     });
 
     test("new allowReleases fire immediately", () async {
-      var pool = new Pool(1);
+      var pool = Pool(1);
       var resource = await pool.request();
 
-      var completer = new Completer();
+      var completer = Completer();
       expect(
           pool.close().then((_) {
             expect(completer.isCompleted, isTrue);
           }),
           completes);
 
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       resource.allowRelease(() => completer.future);
 
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       completer.complete();
     });
 
     test("an onRelease error is piped to the return value", () async {
-      var pool = new Pool(1);
+      var pool = Pool(1);
       var resource = await pool.request();
 
-      var completer = new Completer();
+      var completer = Completer();
       resource.allowRelease(() => completer.future);
 
       expect(pool.done, throwsA("oh no!"));
       expect(pool.close(), throwsA("oh no!"));
 
-      await new Future.delayed(Duration.zero);
+      await Future.delayed(Duration.zero);
       completer.completeError("oh no!");
     });
   });
@@ -440,20 +441,20 @@
 /// Returns a function that will cause the test to fail if it's called.
 ///
 /// This should only be called within a [FakeAsync.run] zone.
-Function expectNoAsync() {
-  var stack = new Trace.current(1);
+void Function() expectNoAsync() {
+  var stack = Trace.current(1);
   return () => registerException(
-      new TestFailure("Expected function not to be called."), stack);
+      TestFailure("Expected function not to be called."), stack);
 }
 
 /// A matcher for Futures that asserts that they don't complete.
 ///
 /// This should only be called within a [FakeAsync.run] zone.
 Matcher get doesNotComplete => predicate((future) {
-      expect(future, new TypeMatcher<Future>());
+      expect(future, TypeMatcher<Future>());
 
-      var stack = new Trace.current(1);
+      var stack = Trace.current(1);
       future.then((_) => registerException(
-          new TestFailure("Expected future not to complete."), stack));
+          TestFailure("Expected future not to complete."), stack));
       return true;
     });