diff --git a/analysis_options.yaml b/analysis_options.yaml
index 24a615c..82ef545 100644
--- a/analysis_options.yaml
+++ b/analysis_options.yaml
@@ -4,3 +4,5 @@
 linter:
   rules:
     - prefer_typing_uninitialized_variables
+    - unnecessary_new
+    - unnecessary_const
diff --git a/lib/src/async_cache.dart b/lib/src/async_cache.dart
index 53084ca..6bd34bd 100644
--- a/lib/src/async_cache.dart
+++ b/lib/src/async_cache.dart
@@ -49,7 +49,7 @@
   /// An ephemeral cache guarantees that a callback function will only be
   /// executed at most once concurrently. This is useful for requests for which
   /// data is updated frequently but stale data is acceptable.
-  factory AsyncCache.ephemeral() => new AsyncCache(Duration.zero);
+  factory AsyncCache.ephemeral() => AsyncCache(Duration.zero);
 
   /// Returns a cached value from a previous call to [fetch], or runs [callback]
   /// to compute a new one.
@@ -58,7 +58,7 @@
   /// value. Otherwise, runs [callback] and returns its new return value.
   Future<T> fetch(Future<T> callback()) async {
     if (_cachedStreamSplitter != null) {
-      throw new StateError('Previously used to cache via `fetchStream`');
+      throw StateError('Previously used to cache via `fetchStream`');
     }
     if (_cachedValueFuture == null) {
       _cachedValueFuture = callback();
@@ -76,11 +76,11 @@
   /// return value.
   Stream<T> fetchStream(Stream<T> callback()) {
     if (_cachedValueFuture != null) {
-      throw new StateError('Previously used to cache via `fetch`');
+      throw StateError('Previously used to cache via `fetch`');
     }
     if (_cachedStreamSplitter == null) {
-      _cachedStreamSplitter = new StreamSplitter(callback()
-          .transform(new StreamTransformer.fromHandlers(handleDone: (sink) {
+      _cachedStreamSplitter = StreamSplitter(callback()
+          .transform(StreamTransformer.fromHandlers(handleDone: (sink) {
         _startStaleTimer();
         sink.close();
       })));
@@ -100,6 +100,6 @@
   }
 
   void _startStaleTimer() {
-    _stale = new Timer(_duration, invalidate);
+    _stale = Timer(_duration, invalidate);
   }
 }
diff --git a/lib/src/async_memoizer.dart b/lib/src/async_memoizer.dart
index d1c0f32..5e83400 100644
--- a/lib/src/async_memoizer.dart
+++ b/lib/src/async_memoizer.dart
@@ -31,7 +31,7 @@
   ///
   /// This can be accessed at any time, and will fire once [runOnce] is called.
   Future<T> get future => _completer.future;
-  final _completer = new Completer<T>();
+  final _completer = Completer<T>();
 
   /// Whether [runOnce] has been called yet.
   bool get hasRun => _completer.isCompleted;
@@ -40,7 +40,7 @@
   ///
   /// If [runOnce] has already been called, this returns the original result.
   Future<T> runOnce(FutureOr<T> computation()) {
-    if (!hasRun) _completer.complete(new Future.sync(computation));
+    if (!hasRun) _completer.complete(Future.sync(computation));
     return future;
   }
 }
diff --git a/lib/src/byte_collector.dart b/lib/src/byte_collector.dart
index 3c1d49d..f01cc2a 100644
--- a/lib/src/byte_collector.dart
+++ b/lib/src/byte_collector.dart
@@ -31,7 +31,7 @@
     Stream<List<int>> source) {
   return _collectBytes(
       source,
-      (subscription, result) => new CancelableOperation.fromFuture(result,
+      (subscription, result) => CancelableOperation.fromFuture(result,
           onCancel: subscription.cancel));
 }
 
@@ -46,7 +46,7 @@
         StreamSubscription<List<int>> subscription, Future<Uint8List> result)) {
   var byteLists = <List<int>>[];
   var length = 0;
-  var completer = new Completer<Uint8List>.sync();
+  var completer = Completer<Uint8List>.sync();
   var subscription = source.listen(
       (bytes) {
         byteLists.add(bytes);
@@ -62,7 +62,7 @@
 
 // Join a lists of bytes with a known total length into a single [Uint8List].
 Uint8List _collect(int length, List<List<int>> byteLists) {
-  var result = new Uint8List(length);
+  var result = Uint8List(length);
   int i = 0;
   for (var byteList in byteLists) {
     var end = i + byteList.length;
diff --git a/lib/src/cancelable_operation.dart b/lib/src/cancelable_operation.dart
index 0e010da..e6115cb 100644
--- a/lib/src/cancelable_operation.dart
+++ b/lib/src/cancelable_operation.dart
@@ -31,7 +31,7 @@
   /// It's guaranteed to only be called once.
   factory CancelableOperation.fromFuture(Future<T> inner,
       {FutureOr onCancel()}) {
-    var completer = new CancelableCompleter<T>(onCancel: onCancel);
+    var completer = CancelableCompleter<T>(onCancel: onCancel);
     completer.complete(inner);
     return completer.operation;
   }
@@ -45,7 +45,7 @@
   /// canceled, this is as well.
   Stream<T> asStream() {
     var controller =
-        new StreamController<T>(sync: true, onCancel: _completer._cancel);
+        StreamController<T>(sync: true, onCancel: _completer._cancel);
 
     value.then((value) {
       controller.add(value);
@@ -64,7 +64,7 @@
   /// If this operation is cancelled, the returned future waits for the future
   /// returned by [cancel], then completes to [cancellationValue].
   Future<T> valueOrCancellation([T cancellationValue]) {
-    var completer = new Completer<T>.sync();
+    var completer = Completer<T>.sync();
     value.then((result) => completer.complete(result),
         onError: completer.completeError);
 
@@ -100,8 +100,8 @@
   /// It's guaranteed to only be called once.
   CancelableCompleter({FutureOr onCancel()})
       : _onCancel = onCancel,
-        _inner = new Completer<T>() {
-    _operation = new CancelableOperation<T>._(this);
+        _inner = Completer<T>() {
+    _operation = CancelableOperation<T>._(this);
   }
 
   /// The operation controlled by this completer.
@@ -117,14 +117,14 @@
   bool _isCanceled = false;
 
   /// The memoizer for [_cancel].
-  final _cancelMemo = new AsyncMemoizer();
+  final _cancelMemo = AsyncMemoizer();
 
   /// Completes [operation] to [value].
   ///
   /// If [value] is a [Future], this will complete to the result of that
   /// [Future] once it completes.
   void complete([value]) {
-    if (_isCompleted) throw new StateError("Operation already completed");
+    if (_isCompleted) throw StateError("Operation already completed");
     _isCompleted = true;
 
     if (value is! Future) {
@@ -150,7 +150,7 @@
 
   /// Completes [operation] to [error].
   void completeError(Object error, [StackTrace stackTrace]) {
-    if (_isCompleted) throw new StateError("Operation already completed");
+    if (_isCompleted) throw StateError("Operation already completed");
     _isCompleted = true;
 
     if (_isCanceled) return;
@@ -159,7 +159,7 @@
 
   /// Cancel the completer.
   Future _cancel() {
-    if (_inner.isCompleted) return new Future.value();
+    if (_inner.isCompleted) return Future.value();
 
     return _cancelMemo.runOnce(() {
       _isCanceled = true;
diff --git a/lib/src/delegate/event_sink.dart b/lib/src/delegate/event_sink.dart
index 54c3e52..95d7841 100644
--- a/lib/src/delegate/event_sink.dart
+++ b/lib/src/delegate/event_sink.dart
@@ -23,7 +23,7 @@
   /// [add] may throw a [CastError] if the argument type doesn't match the
   /// reified type of [sink].
   static EventSink<T> typed<T>(EventSink sink) =>
-      sink is EventSink<T> ? sink : new DelegatingEventSink._(sink);
+      sink is EventSink<T> ? sink : DelegatingEventSink._(sink);
 
   void add(T data) {
     _sink.add(data);
diff --git a/lib/src/delegate/sink.dart b/lib/src/delegate/sink.dart
index 7c68a0f..b8ba76d 100644
--- a/lib/src/delegate/sink.dart
+++ b/lib/src/delegate/sink.dart
@@ -21,7 +21,7 @@
   /// throw a [CastError] if the argument type doesn't match the reified type of
   /// [sink].
   static Sink<T> typed<T>(Sink sink) =>
-      sink is Sink<T> ? sink : new DelegatingSink._(sink);
+      sink is Sink<T> ? sink : DelegatingSink._(sink);
 
   void add(T data) {
     _sink.add(data);
diff --git a/lib/src/delegate/stream_consumer.dart b/lib/src/delegate/stream_consumer.dart
index ba83040..ad53182 100644
--- a/lib/src/delegate/stream_consumer.dart
+++ b/lib/src/delegate/stream_consumer.dart
@@ -25,7 +25,7 @@
   static StreamConsumer<T> typed<T>(StreamConsumer consumer) =>
       consumer is StreamConsumer<T>
           ? consumer
-          : new DelegatingStreamConsumer._(consumer);
+          : DelegatingStreamConsumer._(consumer);
 
   Future addStream(Stream<T> stream) => _consumer.addStream(stream);
 
diff --git a/lib/src/delegate/stream_sink.dart b/lib/src/delegate/stream_sink.dart
index 198df8a..67eb33c 100644
--- a/lib/src/delegate/stream_sink.dart
+++ b/lib/src/delegate/stream_sink.dart
@@ -25,7 +25,7 @@
   /// throw a [CastError] if the argument type doesn't match the reified type of
   /// [sink].
   static StreamSink<T> typed<T>(StreamSink sink) =>
-      sink is StreamSink<T> ? sink : new DelegatingStreamSink._(sink);
+      sink is StreamSink<T> ? sink : DelegatingStreamSink._(sink);
 
   void add(T data) {
     _sink.add(data);
diff --git a/lib/src/delegate/stream_subscription.dart b/lib/src/delegate/stream_subscription.dart
index 6bef924..07af08e 100644
--- a/lib/src/delegate/stream_subscription.dart
+++ b/lib/src/delegate/stream_subscription.dart
@@ -26,7 +26,7 @@
   static StreamSubscription<T> typed<T>(StreamSubscription subscription) =>
       subscription is StreamSubscription<T>
           ? subscription
-          : new TypeSafeStreamSubscription<T>(subscription);
+          : TypeSafeStreamSubscription<T>(subscription);
 
   void onData(void handleData(T data)) {
     _source.onData(handleData);
diff --git a/lib/src/future_group.dart b/lib/src/future_group.dart
index 0bf3158..7e17494 100644
--- a/lib/src/future_group.dart
+++ b/lib/src/future_group.dart
@@ -31,7 +31,7 @@
   /// This will also complete with an error if any of the futures in the group
   /// fails, regardless of whether [close] was called.
   Future<List<T>> get future => _completer.future;
-  final _completer = new Completer<List<T>>();
+  final _completer = Completer<List<T>>();
 
   /// Whether this group has no pending futures.
   bool get isIdle => _pending == 0;
@@ -43,7 +43,7 @@
   /// called, this stream will close.
   Stream get onIdle {
     if (_onIdleController == null) {
-      _onIdleController = new StreamController.broadcast(sync: true);
+      _onIdleController = StreamController.broadcast(sync: true);
     }
     return _onIdleController.stream;
   }
@@ -54,11 +54,11 @@
   /// the order they were added.
   ///
   /// The slots for futures that haven't completed yet are `null`.
-  final _values = new List<T>();
+  final _values = List<T>();
 
   /// Wait for [task] to complete.
   void add(Future<T> task) {
-    if (_closed) throw new StateError("The FutureGroup is closed.");
+    if (_closed) throw StateError("The FutureGroup is closed.");
 
     // Ensure that future values are put into [values] in the same order they're
     // added to the group by pre-allocating a slot for them and recording its
diff --git a/lib/src/lazy_stream.dart b/lib/src/lazy_stream.dart
index f07c387..278957a 100644
--- a/lib/src/lazy_stream.dart
+++ b/lib/src/lazy_stream.dart
@@ -22,13 +22,13 @@
   /// a listener and forwards to the returned stream.
   LazyStream(FutureOr<Stream<T>> callback()) : _callback = callback {
     // Explicitly check for null because we null out [_callback] internally.
-    if (_callback == null) throw new ArgumentError.notNull('callback');
+    if (_callback == null) throw ArgumentError.notNull('callback');
   }
 
   StreamSubscription<T> listen(void onData(T event),
       {Function onError, void onDone(), bool cancelOnError}) {
     if (_callback == null) {
-      throw new StateError("Stream has already been listened to.");
+      throw StateError("Stream has already been listened to.");
     }
 
     // Null out the callback before we invoke it to ensure that even while
diff --git a/lib/src/null_stream_sink.dart b/lib/src/null_stream_sink.dart
index c83790c..c9d3d5d 100644
--- a/lib/src/null_stream_sink.dart
+++ b/lib/src/null_stream_sink.dart
@@ -42,13 +42,13 @@
   ///
   /// If [done] is passed, it's used as the [Sink.done] future. Otherwise, a
   /// completed future is used.
-  NullStreamSink({Future done}) : done = done ?? new Future.value();
+  NullStreamSink({Future done}) : done = done ?? Future.value();
 
   /// Creates a null sink whose [done] future emits [error].
   ///
   /// Note that this error will not be considered uncaught.
   NullStreamSink.error(error, [StackTrace stackTrace])
-      : done = new Future.error(error, stackTrace)
+      : done = Future.error(error, stackTrace)
           // Don't top-level the error. This gives the user a change to call
           // [close] or [done], and matches the behavior of a remote endpoint
           // experiencing an error.
@@ -66,7 +66,7 @@
     _checkEventAllowed();
 
     _addingStream = true;
-    var future = stream.listen(null).cancel() ?? new Future.value();
+    var future = stream.listen(null).cancel() ?? Future.value();
     return future.whenComplete(() {
       _addingStream = false;
     });
@@ -75,9 +75,9 @@
   /// Throws a [StateError] if [close] has been called or an [addStream] call is
   /// pending.
   void _checkEventAllowed() {
-    if (_closed) throw new StateError("Cannot add to a closed sink.");
+    if (_closed) throw StateError("Cannot add to a closed sink.");
     if (_addingStream) {
-      throw new StateError("Cannot add to a sink while adding a stream.");
+      throw StateError("Cannot add to a sink while adding a stream.");
     }
   }
 
diff --git a/lib/src/restartable_timer.dart b/lib/src/restartable_timer.dart
index 7b05821..b8e414a 100644
--- a/lib/src/restartable_timer.dart
+++ b/lib/src/restartable_timer.dart
@@ -26,7 +26,7 @@
   /// The [callback] function is invoked after the given [duration]. Unlike a
   /// normal non-periodic [Timer], [callback] may be called more than once.
   RestartableTimer(this._duration, this._callback) {
-    _timer = new Timer(_duration, _callback);
+    _timer = Timer(_duration, _callback);
   }
 
   bool get isActive => _timer.isActive;
@@ -37,7 +37,7 @@
   /// This restarts the timer even if it has already fired or has been canceled.
   void reset() {
     _timer.cancel();
-    _timer = new Timer(_duration, _callback);
+    _timer = Timer(_duration, _callback);
   }
 
   void cancel() {
@@ -49,6 +49,6 @@
   // See https://github.com/dart-lang/sdk/issues/31664
   // ignore: override_on_non_overriding_getter
   int get tick {
-    throw new UnimplementedError("tick");
+    throw UnimplementedError("tick");
   }
 }
diff --git a/lib/src/result/capture_sink.dart b/lib/src/result/capture_sink.dart
index 742c160..0477a19 100644
--- a/lib/src/result/capture_sink.dart
+++ b/lib/src/result/capture_sink.dart
@@ -13,11 +13,11 @@
   CaptureSink(EventSink<Result<T>> sink) : _sink = sink;
 
   void add(T value) {
-    _sink.add(new Result<T>.value(value));
+    _sink.add(Result<T>.value(value));
   }
 
   void addError(Object error, [StackTrace stackTrace]) {
-    _sink.add(new Result.error(error, stackTrace));
+    _sink.add(Result.error(error, stackTrace));
   }
 
   void close() {
diff --git a/lib/src/result/capture_transformer.dart b/lib/src/result/capture_transformer.dart
index b9a538a..a727a8e 100644
--- a/lib/src/result/capture_transformer.dart
+++ b/lib/src/result/capture_transformer.dart
@@ -15,6 +15,6 @@
   const CaptureStreamTransformer();
 
   Stream<Result<T>> bind(Stream<T> source) =>
-      new Stream<Result<T>>.eventTransformed(
-          source, (sink) => new CaptureSink<T>(sink));
+      Stream<Result<T>>.eventTransformed(
+          source, (sink) => CaptureSink<T>(sink));
 }
diff --git a/lib/src/result/error.dart b/lib/src/result/error.dart
index 2feb2c2..8f29d13 100644
--- a/lib/src/result/error.dart
+++ b/lib/src/result/error.dart
@@ -30,7 +30,7 @@
     sink.addError(error, stackTrace);
   }
 
-  Future<Null> get asFuture => new Future<Null>.error(error, stackTrace);
+  Future<Null> get asFuture => Future<Null>.error(error, stackTrace);
 
   /// Calls an error handler with the error and stacktrace.
   ///
diff --git a/lib/src/result/release_transformer.dart b/lib/src/result/release_transformer.dart
index 01865cc..1aead30 100644
--- a/lib/src/result/release_transformer.dart
+++ b/lib/src/result/release_transformer.dart
@@ -12,9 +12,9 @@
   const ReleaseStreamTransformer();
 
   Stream<T> bind(Stream<Result<T>> source) {
-    return new Stream<T>.eventTransformed(source, _createSink);
+    return Stream<T>.eventTransformed(source, _createSink);
   }
 
   // Since Stream.eventTransformed is not generic, this method can be static.
-  static EventSink<Result> _createSink(EventSink sink) => new ReleaseSink(sink);
+  static EventSink<Result> _createSink(EventSink sink) => ReleaseSink(sink);
 }
diff --git a/lib/src/result/result.dart b/lib/src/result/result.dart
index 25503b5..28799fa 100644
--- a/lib/src/result/result.dart
+++ b/lib/src/result/result.dart
@@ -28,14 +28,14 @@
   /// The result of the transformation is a stream of [Result] values and no
   /// error events. This is the transformer used by [captureStream].
   static const StreamTransformer<Object, Result<Object>>
-      captureStreamTransformer = const CaptureStreamTransformer<Object>();
+      captureStreamTransformer = CaptureStreamTransformer<Object>();
 
   /// A stream transformer that releases a stream of result events.
   ///
   /// The result of the transformation is a stream of values and error events.
   /// This is the transformer used by [releaseStream].
   static const StreamTransformer<Result<Object>, Object>
-      releaseStreamTransformer = const ReleaseStreamTransformer<Object>();
+      releaseStreamTransformer = ReleaseStreamTransformer<Object>();
 
   /// A sink transformer that captures events into [Result]s.
   ///
@@ -43,8 +43,8 @@
   /// values and no error events.
   static const StreamSinkTransformer<Object, Result<Object>>
       captureSinkTransformer =
-      const StreamSinkTransformer<Object, Result<Object>>.fromStreamTransformer(
-          const CaptureStreamTransformer<Object>());
+      StreamSinkTransformer<Object, Result<Object>>.fromStreamTransformer(
+          CaptureStreamTransformer<Object>());
 
   /// A sink transformer that releases result events.
   ///
@@ -52,8 +52,8 @@
   /// error events.
   static const StreamSinkTransformer<Result<Object>, Object>
       releaseSinkTransformer =
-      const StreamSinkTransformer<Result<Object>, Object>.fromStreamTransformer(
-          const ReleaseStreamTransformer<Object>());
+      StreamSinkTransformer<Result<Object>, Object>.fromStreamTransformer(
+          ReleaseStreamTransformer<Object>());
 
   /// Creates a `Result` with the result of calling [computation].
   ///
@@ -62,9 +62,9 @@
   /// the call.
   factory Result(T computation()) {
     try {
-      return new ValueResult<T>(computation());
+      return ValueResult<T>(computation());
     } catch (e, s) {
-      return new ErrorResult(e, s);
+      return ErrorResult(e, s);
     }
   }
 
@@ -77,15 +77,15 @@
   ///
   /// Alias for [ErrorResult.ErrorResult].
   factory Result.error(Object error, [StackTrace stackTrace]) =>
-      new ErrorResult(error, stackTrace);
+      ErrorResult(error, stackTrace);
 
   /// Captures the result of a future into a `Result` future.
   ///
   /// The resulting future will never have an error.
   /// Errors have been converted to an [ErrorResult] value.
   static Future<Result<T>> capture<T>(Future<T> future) {
-    return future.then((value) => new ValueResult(value),
-        onError: (error, stackTrace) => new ErrorResult(error, stackTrace));
+    return future.then((value) => ValueResult(value),
+        onError: (error, stackTrace) => ErrorResult(error, stackTrace));
   }
 
   /// Captures each future in [elements],
@@ -111,13 +111,13 @@
           }
         });
       } else {
-        results.add(new Result<T>.value(element));
+        results.add(Result<T>.value(element));
       }
     }
     if (pending == 0) {
-      return new Future<List<Result<T>>>.value(results);
+      return Future<List<Result<T>>>.value(results);
     }
-    completer = new Completer<List<Result<T>>>();
+    completer = Completer<List<Result<T>>>();
     return completer.future;
   }
 
@@ -136,7 +136,7 @@
   /// The returned stream will not have any error events.
   /// Errors from the source stream have been converted to [ErrorResult]s.
   static Stream<Result<T>> captureStream<T>(Stream<T> source) =>
-      source.transform(new CaptureStreamTransformer<T>());
+      source.transform(CaptureStreamTransformer<T>());
 
   /// Releases a stream of [result] values into a stream of the results.
   ///
@@ -144,7 +144,7 @@
   /// the returned stream as appropriate.
   /// Errors from the source stream become errors in the returned stream.
   static Stream<T> releaseStream<T>(Stream<Result<T>> source) =>
-      source.transform(new ReleaseStreamTransformer<T>());
+      source.transform(ReleaseStreamTransformer<T>());
 
   /// Releases results added to the returned sink as data and errors on [sink].
   ///
@@ -152,7 +152,7 @@
   /// on [sink]. Errors added to the returned sink are forwarded directly to
   /// [sink] and so is the [EventSink.close] calls.
   static EventSink<Result<T>> releaseSink<T>(EventSink<T> sink) =>
-      new ReleaseSink<T>(sink);
+      ReleaseSink<T>(sink);
 
   /// Captures the events of the returned sink into results on [sink].
   ///
@@ -162,7 +162,7 @@
   ///
   /// When the returned sink is closed, so is [sink].
   static EventSink<T> captureSink<T>(EventSink<Result<T>> sink) =>
-      new CaptureSink<T>(sink);
+      CaptureSink<T>(sink);
 
   /// Converts a result of a result to a single result.
   ///
@@ -188,7 +188,7 @@
         return result.asError;
       }
     }
-    return new Result<List<T>>.value(values);
+    return Result<List<T>>.value(values);
   }
 
   /// Whether this result is a value result.
diff --git a/lib/src/result/value.dart b/lib/src/result/value.dart
index edc41fb..dddc9fe 100644
--- a/lib/src/result/value.dart
+++ b/lib/src/result/value.dart
@@ -27,7 +27,7 @@
     sink.add(value);
   }
 
-  Future<T> get asFuture => new Future.value(value);
+  Future<T> get asFuture => Future.value(value);
 
   int get hashCode => value.hashCode ^ 0x323f1d61;
 
diff --git a/lib/src/single_subscription_transformer.dart b/lib/src/single_subscription_transformer.dart
index ff17189..8007a42 100644
--- a/lib/src/single_subscription_transformer.dart
+++ b/lib/src/single_subscription_transformer.dart
@@ -18,8 +18,8 @@
 
   Stream<T> bind(Stream<S> stream) {
     StreamSubscription<S> subscription;
-    var controller = new StreamController<T>(
-        sync: true, onCancel: () => subscription.cancel());
+    var controller =
+        StreamController<T>(sync: true, onCancel: () => subscription.cancel());
     subscription = stream.listen((value) {
       // TODO(nweiz): When we release a new major version, get rid of the second
       // type parameter and avoid this conversion.
diff --git a/lib/src/stream_completer.dart b/lib/src/stream_completer.dart
index 4311de5..bbb2155 100644
--- a/lib/src/stream_completer.dart
+++ b/lib/src/stream_completer.dart
@@ -24,7 +24,7 @@
 /// the listen is performed directly on the source stream.
 class StreamCompleter<T> {
   /// The stream doing the actual work, is returned by [stream].
-  final _stream = new _CompleterStream<T>();
+  final _stream = _CompleterStream<T>();
 
   /// Convert a `Future<Stream>` to a `Stream`.
   ///
@@ -35,7 +35,7 @@
   /// If the future completes with an error, the returned stream will
   /// instead contain just that error.
   static Stream<T> fromFuture<T>(Future<Stream<T>> streamFuture) {
-    var completer = new StreamCompleter<T>();
+    var completer = StreamCompleter<T>();
     streamFuture.then(completer.setSourceStream, onError: completer.setError);
     return completer.stream;
   }
@@ -75,7 +75,7 @@
   /// most once. Trying to call any of them again will fail.
   void setSourceStream(Stream<T> sourceStream) {
     if (_stream._isSourceStreamSet) {
-      throw new StateError("Source stream already set");
+      throw StateError("Source stream already set");
     }
     _stream._setSourceStream(sourceStream);
   }
@@ -86,7 +86,7 @@
   /// most once. Trying to call any of them again will fail.
   void setEmpty() {
     if (_stream._isSourceStreamSet) {
-      throw new StateError("Source stream already set");
+      throw StateError("Source stream already set");
     }
     _stream._setEmpty();
   }
@@ -98,7 +98,7 @@
   /// Any one of [setSourceStream], [setEmpty], and [setError] may be called at
   /// most once. Trying to call any of them again will fail.
   void setError(error, [StackTrace stackTrace]) {
-    setSourceStream(new Stream.fromFuture(new Future.error(error, stackTrace)));
+    setSourceStream(Stream.fromFuture(Future.error(error, stackTrace)));
   }
 }
 
@@ -179,6 +179,6 @@
   // Creates the [_controller].
   void _createController() {
     assert(_controller == null);
-    _controller = new StreamController<T>(sync: true);
+    _controller = StreamController<T>(sync: true);
   }
 }
diff --git a/lib/src/stream_group.dart b/lib/src/stream_group.dart
index 6361a5c..d647ce3 100644
--- a/lib/src/stream_group.dart
+++ b/lib/src/stream_group.dart
@@ -47,14 +47,14 @@
   /// subscriptions will be canceled and set to null again. Single-subscriber
   /// stream subscriptions will be left intact, since they can't be
   /// re-subscribed.
-  final _subscriptions = new Map<Stream<T>, StreamSubscription<T>>();
+  final _subscriptions = Map<Stream<T>, StreamSubscription<T>>();
 
   /// Merges the events from [streams] into a single (single-subscriber) stream.
   ///
   /// This is equivalent to adding [streams] to a group, closing that group, and
   /// returning its stream.
   static Stream<T> merge<T>(Iterable<Stream<T>> streams) {
-    var group = new StreamGroup<T>();
+    var group = StreamGroup<T>();
     streams.forEach(group.add);
     group.close();
     return group.stream;
@@ -62,7 +62,7 @@
 
   /// Creates a new stream group where [stream] is single-subscriber.
   StreamGroup() {
-    _controller = new StreamController<T>(
+    _controller = StreamController<T>(
         onListen: _onListen,
         onPause: _onPause,
         onResume: _onResume,
@@ -72,7 +72,7 @@
 
   /// Creates a new stream group where [stream] is a broadcast stream.
   StreamGroup.broadcast() {
-    _controller = new StreamController<T>.broadcast(
+    _controller = StreamController<T>.broadcast(
         onListen: _onListen, onCancel: _onCancelBroadcast, sync: true);
   }
 
@@ -90,7 +90,7 @@
   /// Throws a [StateError] if this group is closed.
   Future add(Stream<T> stream) {
     if (_closed) {
-      throw new StateError("Can't add a Stream to a closed StreamGroup.");
+      throw StateError("Can't add a Stream to a closed StreamGroup.");
     }
 
     if (_state == _StreamGroupState.dormant) {
@@ -219,12 +219,12 @@
   ///
   /// New streams added to the group will be listened once the group has a
   /// listener.
-  static const dormant = const _StreamGroupState("dormant");
+  static const dormant = _StreamGroupState("dormant");
 
   /// The group has one or more listeners and is actively firing events.
   ///
   /// New streams added to the group will be immediately listeners.
-  static const listening = const _StreamGroupState("listening");
+  static const listening = _StreamGroupState("listening");
 
   /// The group is paused and no more events will be fired until it resumes.
   ///
@@ -232,7 +232,7 @@
   /// will be resumed once the group itself is resumed.
   ///
   /// This state is only used by single-subscriber groups.
-  static const paused = const _StreamGroupState("paused");
+  static const paused = _StreamGroupState("paused");
 
   /// The group is canceled and no more events will be fired ever.
   ///
@@ -240,7 +240,7 @@
   /// discarded.
   ///
   /// This state is only used by single-subscriber groups.
-  static const canceled = const _StreamGroupState("canceled");
+  static const canceled = _StreamGroupState("canceled");
 
   /// The name of the state.
   ///
diff --git a/lib/src/stream_queue.dart b/lib/src/stream_queue.dart
index 61a1654..fd3186e 100644
--- a/lib/src/stream_queue.dart
+++ b/lib/src/stream_queue.dart
@@ -44,7 +44,7 @@
 ///
 /// Example:
 ///
-///     var events = new StreamQueue<String>(someStreamOfLines);
+///     var events = StreamQueue<String>(someStreamOfLines);
 ///     var first = await events.next;
 ///     while (first.startsWith('#')) {
 ///       // Skip comments.
@@ -107,12 +107,12 @@
   var _eventsReceived = 0;
 
   /// Queue of events not used by a request yet.
-  final QueueList<Result<T>> _eventQueue = new QueueList();
+  final QueueList<Result<T>> _eventQueue = QueueList();
 
   /// Queue of pending requests.
   ///
   /// Access through methods below to ensure consistency.
-  final Queue<_EventRequest> _requestQueue = new Queue();
+  final Queue<_EventRequest> _requestQueue = Queue();
 
   /// Create a `StreamQueue` of the events of [source].
   factory StreamQueue(Stream<T> source) => StreamQueue._(source);
@@ -133,7 +133,7 @@
   /// one events.
   Future<bool> get hasNext {
     if (!_isClosed) {
-      var hasNextRequest = new _HasNextRequest<T>();
+      var hasNextRequest = _HasNextRequest<T>();
       _addRequest(hasNextRequest);
       return hasNextRequest.future;
     }
@@ -146,9 +146,9 @@
   /// If one of the next [count] events is an error, the returned future
   /// completes with this error, and the error is still left in the queue.
   Future<List<T>> lookAhead(int count) {
-    if (count < 0) throw new RangeError.range(count, 0, null, "count");
+    if (count < 0) throw RangeError.range(count, 0, null, "count");
     if (!_isClosed) {
-      var request = new _LookAheadRequest<T>(count);
+      var request = _LookAheadRequest<T>(count);
       _addRequest(request);
       return request.future;
     }
@@ -171,7 +171,7 @@
   /// first events that were not consumed by previous requeusts.
   Future<T> get next {
     if (!_isClosed) {
-      var nextRequest = new _NextRequest<T>();
+      var nextRequest = _NextRequest<T>();
       _addRequest(nextRequest);
       return nextRequest.future;
     }
@@ -184,7 +184,7 @@
   /// If the next event is an error event, it stays in the queue.
   Future<T> get peek {
     if (!_isClosed) {
-      var nextRequest = new _PeekRequest<T>();
+      var nextRequest = _PeekRequest<T>();
       _addRequest(nextRequest);
       return nextRequest.future;
     }
@@ -204,7 +204,7 @@
     if (_isClosed) {
       throw _failClosed();
     }
-    var request = new _RestRequest<T>(this);
+    var request = _RestRequest<T>(this);
     _isClosed = true;
     _addRequest(request);
     return request.stream;
@@ -226,9 +226,9 @@
   /// then all events were succssfully skipped. If the value
   /// is greater than zero then the stream ended early.
   Future<int> skip(int count) {
-    if (count < 0) throw new RangeError.range(count, 0, null, "count");
+    if (count < 0) throw RangeError.range(count, 0, null, "count");
     if (!_isClosed) {
-      var request = new _SkipRequest<T>(count);
+      var request = _SkipRequest<T>(count);
       _addRequest(request);
       return request.future;
     }
@@ -251,9 +251,9 @@
   /// of data collected so far. That is, the returned
   /// list may have fewer than [count] elements.
   Future<List<T>> take(int count) {
-    if (count < 0) throw new RangeError.range(count, 0, null, "count");
+    if (count < 0) throw RangeError.range(count, 0, null, "count");
     if (!_isClosed) {
-      var request = new _TakeRequest<T>(count);
+      var request = _TakeRequest<T>(count);
       _addRequest(request);
       return request.future;
     }
@@ -295,7 +295,7 @@
   StreamQueueTransaction<T> startTransaction() {
     if (_isClosed) throw _failClosed();
 
-    var request = new _TransactionRequest(this);
+    var request = _TransactionRequest(this);
     _addRequest(request);
     return request.transaction;
   }
@@ -353,7 +353,7 @@
   /// See also [startTransaction] and [withTransaction].
   ///
   /// ```dart
-  /// final _stdinQueue = new StreamQueue(stdin);
+  /// final _stdinQueue = StreamQueue(stdin);
   ///
   /// /// Returns an operation that completes when the user sends a line to
   /// /// standard input.
@@ -365,7 +365,7 @@
   CancelableOperation<S> cancelable<S>(
       Future<S> callback(StreamQueue<T> queue)) {
     var transaction = startTransaction();
-    var completer = new CancelableCompleter<S>(onCancel: () {
+    var completer = CancelableCompleter<S>(onCancel: () {
       transaction.reject();
     });
 
@@ -393,17 +393,17 @@
   /// After calling `cancel`, no further events can be requested.
   /// None of [lookAhead], [next], [peek], [rest], [skip], [take] or [cancel]
   /// may be called again.
-  Future cancel({bool immediate: false}) {
+  Future cancel({bool immediate = false}) {
     if (_isClosed) throw _failClosed();
     _isClosed = true;
 
     if (!immediate) {
-      var request = new _CancelRequest<T>(this);
+      var request = _CancelRequest<T>(this);
       _addRequest(request);
       return request.future;
     }
 
-    if (_isDone && _eventQueue.isEmpty) return new Future.value();
+    if (_isDone && _eventQueue.isEmpty) return Future.value();
     return _cancel();
   }
 
@@ -444,7 +444,7 @@
   Stream<T> _extractStream() {
     assert(_isClosed);
     if (_isDone) {
-      return new Stream<T>.empty();
+      return Stream<T>.empty();
     }
     _isDone = true;
 
@@ -456,7 +456,7 @@
     _subscription = null;
 
     var wasPaused = subscription.isPaused;
-    var result = new SubscriptionStream<T>(subscription);
+    var result = SubscriptionStream<T>(subscription);
     // Resume after creating stream because that pauses the subscription too.
     // This way there won't be a short resumption in the middle.
     if (wasPaused) subscription.resume();
@@ -481,9 +481,9 @@
     if (_isDone) return;
     if (_subscription == null) {
       _subscription = _source.listen((data) {
-        _addResult(new Result.value(data));
+        _addResult(Result.value(data));
       }, onError: (error, StackTrace stackTrace) {
-        _addResult(new Result.error(error, stackTrace));
+        _addResult(Result.error(error, stackTrace));
       }, onDone: () {
         _subscription = null;
         this._close();
@@ -529,7 +529,7 @@
   /// Returns a [StateError] with a message saying that either
   /// [cancel] or [rest] have already been called.
   Error _failClosed() {
-    return new StateError("Already cancelled");
+    return StateError("Already cancelled");
   }
 
   /// Adds a new request to the queue.
@@ -558,7 +558,7 @@
   final StreamSplitter<T> _splitter;
 
   /// Queues created using [newQueue].
-  final _queues = new Set<StreamQueue>();
+  final _queues = Set<StreamQueue>();
 
   /// Whether [commit] has been called.
   var _committed = false;
@@ -567,7 +567,7 @@
   var _rejected = false;
 
   StreamQueueTransaction._(this._parent, Stream<T> source)
-      : _splitter = new StreamSplitter(source);
+      : _splitter = StreamSplitter(source);
 
   /// Creates a new copy of the parent queue.
   ///
@@ -575,7 +575,7 @@
   /// [StreamQueue.startTransaction] was called. Its position can be committed
   /// to the parent queue using [commit].
   StreamQueue<T> newQueue() {
-    var queue = new StreamQueue(_splitter.split());
+    var queue = StreamQueue(_splitter.split());
     _queues.add(queue);
     return queue;
   }
@@ -592,9 +592,9 @@
   void commit(StreamQueue<T> queue) {
     _assertActive();
     if (!_queues.contains(queue)) {
-      throw new ArgumentError("Queue doesn't belong to this transaction.");
+      throw ArgumentError("Queue doesn't belong to this transaction.");
     } else if (queue._requestQueue.isNotEmpty) {
-      throw new StateError("A queue with pending requests can't be committed.");
+      throw StateError("A queue with pending requests can't be committed.");
     }
     _committed = true;
 
@@ -639,9 +639,9 @@
   /// Throws a [StateError] if [accept] or [reject] has already been called.
   void _assertActive() {
     if (_committed) {
-      throw new StateError("This transaction has already been accepted.");
+      throw StateError("This transaction has already been accepted.");
     } else if (_rejected) {
-      throw new StateError("This transaction has already been rejected.");
+      throw StateError("This transaction has already been rejected.");
     }
   }
 }
@@ -690,7 +690,7 @@
 /// and is then complete.
 class _NextRequest<T> implements _EventRequest<T> {
   /// Completer for the future returned by [StreamQueue.next].
-  final _completer = new Completer<T>();
+  final _completer = Completer<T>();
 
   _NextRequest();
 
@@ -702,8 +702,7 @@
       return true;
     }
     if (isDone) {
-      _completer.completeError(
-          new StateError("No elements"), StackTrace.current);
+      _completer.completeError(StateError("No elements"), StackTrace.current);
       return true;
     }
     return false;
@@ -716,7 +715,7 @@
 /// and is then complete, but doesn't consume the event.
 class _PeekRequest<T> implements _EventRequest<T> {
   /// Completer for the future returned by [StreamQueue.next].
-  final _completer = new Completer<T>();
+  final _completer = Completer<T>();
 
   _PeekRequest();
 
@@ -728,8 +727,7 @@
       return true;
     }
     if (isDone) {
-      _completer.completeError(
-          new StateError("No elements"), StackTrace.current);
+      _completer.completeError(StateError("No elements"), StackTrace.current);
       return true;
     }
     return false;
@@ -739,7 +737,7 @@
 /// Request for a [StreamQueue.skip] call.
 class _SkipRequest<T> implements _EventRequest<T> {
   /// Completer for the future returned by the skip call.
-  final _completer = new Completer<int>();
+  final _completer = Completer<int>();
 
   /// Number of remaining events to skip.
   ///
@@ -776,7 +774,7 @@
 /// Common superclass for [_TakeRequest] and [_LookAheadRequest].
 abstract class _ListRequest<T> implements _EventRequest<T> {
   /// Completer for the future returned by the take call.
-  final _completer = new Completer<List<T>>();
+  final _completer = Completer<List<T>>();
 
   /// List collecting events until enough have been seen.
   final _list = <T>[];
@@ -846,7 +844,7 @@
 class _CancelRequest<T> implements _EventRequest<T> {
   /// Completer for the future returned by the `cancel` call.
   /// TODO(lrn); make this Completer<void> when that is implemented.
-  final _completer = new Completer();
+  final _completer = Completer();
 
   /// When the event is completed, it needs to cancel the active subscription
   /// of the `StreamQueue` object, if any.
@@ -875,7 +873,7 @@
 /// stream events subscription and creates a stream from it.
 class _RestRequest<T> implements _EventRequest<T> {
   /// Completer for the stream returned by the `rest` call.
-  final _completer = new StreamCompleter<T>();
+  final _completer = StreamCompleter<T>();
 
   /// The [StreamQueue] object that has this request queued.
   ///
@@ -898,7 +896,7 @@
     } else {
       // There are prefetched events which needs to be added before the
       // remaining stream.
-      var controller = new StreamController<T>();
+      var controller = StreamController<T>();
       for (var event in events) {
         event.addTo(controller);
       }
@@ -918,7 +916,7 @@
 /// If the request is closed without seeing an event, then
 /// the [future] is completed with `false`.
 class _HasNextRequest<T> implements _EventRequest<T> {
-  final _completer = new Completer<bool>();
+  final _completer = Completer<bool>();
 
   Future<bool> get future => _completer.future;
 
@@ -947,13 +945,13 @@
   StreamQueueTransaction<T> _transaction;
 
   /// The controller that passes events to [transaction].
-  final _controller = new StreamController<T>(sync: true);
+  final _controller = StreamController<T>(sync: true);
 
   /// The number of events passed to [_controller] so far.
   var _eventsSent = 0;
 
   _TransactionRequest(StreamQueue<T> parent) {
-    _transaction = new StreamQueueTransaction._(parent, _controller.stream);
+    _transaction = StreamQueueTransaction._(parent, _controller.stream);
   }
 
   bool update(QueueList<Result<T>> events, bool isDone) {
diff --git a/lib/src/stream_sink_completer.dart b/lib/src/stream_sink_completer.dart
index 4219126..c7fdd03 100644
--- a/lib/src/stream_sink_completer.dart
+++ b/lib/src/stream_sink_completer.dart
@@ -24,7 +24,7 @@
   ///
   /// Events can be added to the sink either before or after a destination sink
   /// is set.
-  final StreamSink<T> sink = new _CompleterSink<T>();
+  final StreamSink<T> sink = _CompleterSink<T>();
 
   /// Returns [sink] typed as a [_CompleterSink].
   _CompleterSink<T> get _sink => sink;
@@ -37,7 +37,7 @@
   /// If the future completes with an error, the returned sink will instead
   /// be closed. Its [Sink.done] future will contain the error.
   static StreamSink<T> fromFuture<T>(Future<StreamSink<T>> sinkFuture) {
-    var completer = new StreamSinkCompleter<T>();
+    var completer = StreamSinkCompleter<T>();
     sinkFuture.then(completer.setDestinationSink, onError: completer.setError);
     return completer.sink;
   }
@@ -59,7 +59,7 @@
   /// Trying to call either of them again will fail.
   void setDestinationSink(StreamSink<T> destinationSink) {
     if (_sink._destinationSink != null) {
-      throw new StateError("Destination sink already set");
+      throw StateError("Destination sink already set");
     }
     _sink._setDestinationSink(destinationSink);
   }
@@ -71,7 +71,7 @@
   /// Either of [setDestinationSink] or [setError] may be called at most once.
   /// Trying to call either of them again will fail.
   void setError(error, [StackTrace stackTrace]) {
-    setDestinationSink(new NullStreamSink.error(error, stackTrace));
+    setDestinationSink(NullStreamSink.error(error, stackTrace));
   }
 }
 
@@ -101,7 +101,7 @@
   Future get done {
     if (_doneCompleter != null) return _doneCompleter.future;
     if (_destinationSink == null) {
-      _doneCompleter = new Completer.sync();
+      _doneCompleter = Completer.sync();
       return _doneCompleter.future;
     }
     return _destinationSink.done;
@@ -144,7 +144,7 @@
 
   /// Create [_controller] if it doesn't yet exist.
   void _ensureController() {
-    if (_controller == null) _controller = new StreamController(sync: true);
+    if (_controller == null) _controller = StreamController(sync: true);
   }
 
   /// Sets the destination sink to which events from this sink will be provided.
diff --git a/lib/src/stream_sink_transformer.dart b/lib/src/stream_sink_transformer.dart
index 503d28a..b01132e 100644
--- a/lib/src/stream_sink_transformer.dart
+++ b/lib/src/stream_sink_transformer.dart
@@ -37,7 +37,7 @@
       {void handleData(S data, EventSink<T> sink),
       void handleError(Object error, StackTrace stackTrace, EventSink<T> sink),
       void handleDone(EventSink<T> sink)}) {
-    return new HandlerTransformer<S, T>(handleData, handleError, handleDone);
+    return HandlerTransformer<S, T>(handleData, handleError, handleDone);
   }
 
   /// Transforms the events passed to [sink].
@@ -57,5 +57,5 @@
           StreamSinkTransformer transformer) =>
       transformer is StreamSinkTransformer<S, T>
           ? transformer
-          : new TypeSafeStreamSinkTransformer(transformer);
+          : TypeSafeStreamSinkTransformer(transformer);
 }
diff --git a/lib/src/stream_sink_transformer/handler_transformer.dart b/lib/src/stream_sink_transformer/handler_transformer.dart
index dba8240..3137003 100644
--- a/lib/src/stream_sink_transformer/handler_transformer.dart
+++ b/lib/src/stream_sink_transformer/handler_transformer.dart
@@ -8,14 +8,14 @@
 import '../delegate/stream_sink.dart';
 
 /// The type of the callback for handling data events.
-typedef void HandleData<S, T>(S data, EventSink<T> sink);
+typedef HandleData<S, T> = void Function(S data, EventSink<T> sink);
 
 /// The type of the callback for handling error events.
-typedef void HandleError<T>(
+typedef HandleError<T> = void Function(
     Object error, StackTrace stackTrace, EventSink<T> sink);
 
 /// The type of the callback for handling done events.
-typedef void HandleDone<T>(EventSink<T> sink);
+typedef HandleDone<T> = void Function(EventSink<T> sink);
 
 /// A [StreamSinkTransformer] that delegates events to the given handlers.
 class HandlerTransformer<S, T> implements StreamSinkTransformer<S, T> {
@@ -30,7 +30,7 @@
 
   HandlerTransformer(this._handleData, this._handleError, this._handleDone);
 
-  StreamSink<S> bind(StreamSink<T> sink) => new _HandlerSink<S, T>(this, sink);
+  StreamSink<S> bind(StreamSink<T> sink) => _HandlerSink<S, T>(this, sink);
 }
 
 /// A sink created by [HandlerTransformer].
@@ -49,7 +49,7 @@
 
   _HandlerSink(this._transformer, StreamSink<T> inner)
       : _inner = inner,
-        _safeCloseInner = new _SafeCloseSink<T>(inner);
+        _safeCloseInner = _SafeCloseSink<T>(inner);
 
   void add(S event) {
     if (_transformer._handleData == null) {
@@ -69,7 +69,7 @@
 
   Future addStream(Stream<S> stream) {
     return _inner.addStream(stream.transform(
-        new StreamTransformer<S, T>.fromHandlers(
+        StreamTransformer<S, T>.fromHandlers(
             handleData: _transformer._handleData,
             handleError: _transformer._handleError,
             handleDone: _closeSink)));
diff --git a/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart b/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
index 32ac648..1010f9f 100644
--- a/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
+++ b/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
@@ -14,7 +14,7 @@
   const StreamTransformerWrapper(this._transformer);
 
   StreamSink<S> bind(StreamSink<T> sink) =>
-      new _StreamTransformerWrapperSink<S, T>(_transformer, sink);
+      _StreamTransformerWrapperSink<S, T>(_transformer, sink);
 }
 
 /// A sink created by [StreamTransformerWrapper].
@@ -23,7 +23,7 @@
   ///
   /// This is used to create a stream that can be transformed by the wrapped
   /// transformer.
-  final _controller = new StreamController<S>(sync: true);
+  final _controller = StreamController<S>(sync: true);
 
   /// The original sink that's being transformed.
   final StreamSink<T> _inner;
diff --git a/lib/src/stream_splitter.dart b/lib/src/stream_splitter.dart
index 3616501..9ddb63a 100644
--- a/lib/src/stream_splitter.dart
+++ b/lib/src/stream_splitter.dart
@@ -32,20 +32,20 @@
 
   /// The buffer of events or errors that have already been emitted by
   /// [_stream].
-  final _buffer = new List<Result<T>>();
+  final _buffer = List<Result<T>>();
 
   /// The controllers for branches that are listening for future events from
   /// [_stream].
   ///
   /// Once a branch is canceled, it's removed from this list. When [_stream] is
   /// done, all branches are removed.
-  final _controllers = new Set<StreamController<T>>();
+  final _controllers = Set<StreamController<T>>();
 
   /// A group of futures returned by [close].
   ///
   /// This is used to ensure that [close] doesn't complete until all
   /// [StreamController.close] and [StreamSubscription.cancel] calls complete.
-  final _closeGroup = new FutureGroup();
+  final _closeGroup = FutureGroup();
 
   /// Whether [_stream] is done emitting events.
   var _isDone = false;
@@ -59,8 +59,8 @@
   /// then closing the [StreamSplitter].
   static List<Stream<T>> splitFrom<T>(Stream<T> stream, [int count]) {
     if (count == null) count = 2;
-    var splitter = new StreamSplitter<T>(stream);
-    var streams = new List<Stream<T>>.generate(count, (_) => splitter.split());
+    var splitter = StreamSplitter<T>(stream);
+    var streams = List<Stream<T>>.generate(count, (_) => splitter.split());
     splitter.close();
     return streams;
   }
@@ -72,10 +72,10 @@
   /// This will throw a [StateError] if [close] has been called.
   Stream<T> split() {
     if (_isClosed) {
-      throw new StateError("Can't call split() on a closed StreamSplitter.");
+      throw StateError("Can't call split() on a closed StreamSplitter.");
     }
 
-    var controller = new StreamController<T>(
+    var controller = StreamController<T>(
         onListen: _onListen, onPause: _onPause, onResume: _onResume);
     controller.onCancel = () => _onCancel(controller);
 
@@ -183,7 +183,7 @@
 
   /// Buffers [data] and passes it to [_controllers].
   void _onData(T data) {
-    if (!_isClosed) _buffer.add(new Result.value(data));
+    if (!_isClosed) _buffer.add(Result.value(data));
     for (var controller in _controllers) {
       controller.add(data);
     }
@@ -191,7 +191,7 @@
 
   /// Buffers [error] and passes it to [_controllers].
   void _onError(Object error, StackTrace stackTrace) {
-    if (!_isClosed) _buffer.add(new Result.error(error, stackTrace));
+    if (!_isClosed) _buffer.add(Result.error(error, stackTrace));
     for (var controller in _controllers) {
       controller.addError(error, stackTrace);
     }
diff --git a/lib/src/stream_subscription_transformer.dart b/lib/src/stream_subscription_transformer.dart
index 1443b18..bee96a5 100644
--- a/lib/src/stream_subscription_transformer.dart
+++ b/lib/src/stream_subscription_transformer.dart
@@ -6,9 +6,9 @@
 
 import 'async_memoizer.dart';
 
-typedef Future _AsyncHandler<T>(StreamSubscription<T> inner);
+typedef _AsyncHandler<T> = Future Function(StreamSubscription<T> inner);
 
-typedef void _VoidHandler<T>(StreamSubscription<T> inner);
+typedef _VoidHandler<T> = void Function(StreamSubscription<T> inner);
 
 /// Creates a [StreamTransformer] that modifies the behavior of subscriptions to
 /// a stream.
@@ -31,8 +31,8 @@
     {Future handleCancel(StreamSubscription<T> inner),
     void handlePause(StreamSubscription<T> inner),
     void handleResume(StreamSubscription<T> inner)}) {
-  return new StreamTransformer((stream, cancelOnError) {
-    return new _TransformedSubscription(
+  return StreamTransformer((stream, cancelOnError) {
+    return _TransformedSubscription(
         stream.listen(null, cancelOnError: cancelOnError),
         handleCancel ?? (inner) => inner.cancel(),
         handlePause ??
@@ -88,7 +88,7 @@
         _inner = null;
         return _handleCancel(inner);
       });
-  final _cancelMemoizer = new AsyncMemoizer();
+  final _cancelMemoizer = AsyncMemoizer();
 
   void pause([Future resumeFuture]) {
     if (_cancelMemoizer.hasRun) return;
@@ -102,5 +102,5 @@
   }
 
   Future<E> asFuture<E>([E futureValue]) =>
-      _inner?.asFuture(futureValue) ?? new Completer<E>().future;
+      _inner?.asFuture(futureValue) ?? Completer<E>().future;
 }
diff --git a/lib/src/stream_zip.dart b/lib/src/stream_zip.dart
index 3d5a811..ef14c3e 100644
--- a/lib/src/stream_zip.dart
+++ b/lib/src/stream_zip.dart
@@ -31,7 +31,7 @@
       dataCount++;
       if (dataCount == subscriptions.length) {
         var data = current;
-        current = new List(subscriptions.length);
+        current = List(subscriptions.length);
         dataCount = 0;
         for (int i = 0; i < subscriptions.length; i++) {
           if (i != index) subscriptions[i].resume();
@@ -84,9 +84,9 @@
       rethrow;
     }
 
-    current = new List(subscriptions.length);
+    current = List(subscriptions.length);
 
-    controller = new StreamController<List<T>>(onPause: () {
+    controller = StreamController<List<T>>(onPause: () {
       for (int i = 0; i < subscriptions.length; i++) {
         // This may pause some subscriptions more than once.
         // These will not be resumed by onResume below, but must wait for the
diff --git a/lib/src/subscription_stream.dart b/lib/src/subscription_stream.dart
index a235663..347c346 100644
--- a/lib/src/subscription_stream.dart
+++ b/lib/src/subscription_stream.dart
@@ -41,14 +41,14 @@
   StreamSubscription<T> listen(void onData(T event),
       {Function onError, void onDone(), bool cancelOnError}) {
     if (_source == null) {
-      throw new StateError("Stream has already been listened to.");
+      throw StateError("Stream has already been listened to.");
     }
     cancelOnError = (true == cancelOnError);
     var subscription = _source;
     _source = null;
 
     var result = cancelOnError
-        ? new _CancelOnErrorSubscriptionWrapper<T>(subscription)
+        ? _CancelOnErrorSubscriptionWrapper<T>(subscription)
         : subscription;
     result.onData(onData);
     result.onError(onError);
diff --git a/lib/src/typed_stream_transformer.dart b/lib/src/typed_stream_transformer.dart
index cb63311..9750eb4 100644
--- a/lib/src/typed_stream_transformer.dart
+++ b/lib/src/typed_stream_transformer.dart
@@ -16,7 +16,7 @@
         StreamTransformer transformer) =>
     transformer is StreamTransformer<S, T>
         ? transformer
-        : new _TypeSafeStreamTransformer(transformer);
+        : _TypeSafeStreamTransformer(transformer);
 
 /// A wrapper that coerces the type of the stream returned by an inner
 /// transformer.
diff --git a/lib/src/utils.dart b/lib/src/utils.dart
index 2aab40e..39e5a8a 100644
--- a/lib/src/utils.dart
+++ b/lib/src/utils.dart
@@ -5,8 +5,8 @@
 import 'dart:async';
 
 /// A generic typedef for a function that takes one type and returns another.
-typedef F UnaryFunction<E, F>(E argument);
+typedef UnaryFunction<E, F> = F Function(E argument);
 
 /// A typedef for a function that takes no arguments and returns a Future or a
 /// value.
-typedef FutureOr<T> FutureOrCallback<T>();
+typedef FutureOrCallback<T> = FutureOr<T> Function();
diff --git a/pubspec.yaml b/pubspec.yaml
index 37db660..0b79178 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -6,7 +6,7 @@
 homepage: https://www.github.com/dart-lang/async
 
 environment:
-  sdk: '>=2.0.0-dev.23.0 <3.0.0'
+  sdk: '>=2.0.0 <3.0.0'
 
 dependencies:
   collection: ^1.5.0
diff --git a/test/async_cache_test.dart b/test/async_cache_test.dart
index a4f452f..92e34bf 100644
--- a/test/async_cache_test.dart
+++ b/test/async_cache_test.dart
@@ -13,7 +13,7 @@
 
   setUp(() {
     // Create a cache that is fresh for an hour.
-    cache = new AsyncCache(const Duration(hours: 1));
+    cache = AsyncCache(const Duration(hours: 1));
   });
 
   test('should fetch via a callback when no cache exists', () async {
@@ -27,16 +27,16 @@
 
   test('should not fetch via callback when a future is in-flight', () async {
     // No actual caching is done, just avoid duplicate requests.
-    cache = new AsyncCache.ephemeral();
+    cache = AsyncCache.ephemeral();
 
-    var completer = new Completer<String>();
+    var completer = Completer<String>();
     expect(cache.fetch(() => completer.future), completion('Expensive'));
     expect(cache.fetch(expectAsync0(() {}, count: 0)), completion('Expensive'));
     completer.complete('Expensive');
   });
 
   test('should fetch via a callback again when cache expires', () {
-    new FakeAsync().run((fakeAsync) async {
+    FakeAsync().run((fakeAsync) async {
       var timesCalled = 0;
       call() async => 'Called ${++timesCalled}';
       expect(await cache.fetch(call), 'Called 1');
@@ -67,7 +67,7 @@
   test('should fetch a stream via a callback', () async {
     expect(
         await cache.fetchStream(expectAsync0(() {
-          return new Stream.fromIterable(['1', '2', '3']);
+          return Stream.fromIterable(['1', '2', '3']);
         })).toList(),
         ['1', '2', '3']);
   });
@@ -86,22 +86,22 @@
     // Unlike the above test, we want to verify that we don't make multiple
     // calls if a cache is being filled currently, and instead wait for that
     // cache to be completed.
-    var controller = new StreamController<String>();
+    var controller = StreamController<String>();
     Stream<String> call() => controller.stream;
     expect(cache.fetchStream(call).toList(), completion(['1', '2', '3']));
     controller.add('1');
     controller.add('2');
-    await new Future.value();
+    await Future.value();
     expect(cache.fetchStream(call).toList(), completion(['1', '2', '3']));
     controller.add('3');
     await controller.close();
   });
 
   test('should fetch stream via a callback again when cache expires', () {
-    new FakeAsync().run((fakeAsync) async {
+    FakeAsync().run((fakeAsync) async {
       var timesCalled = 0;
       Stream<String> call() {
-        return new Stream.fromIterable(['Called ${++timesCalled}']);
+        return Stream.fromIterable(['Called ${++timesCalled}']);
       }
 
       expect(await cache.fetchStream(call).toList(), ['Called 1']);
@@ -125,7 +125,7 @@
   test('should fetch via a callback when manually invalidated', () async {
     var timesCalled = 0;
     Stream<String> call() {
-      return new Stream.fromIterable(['Called ${++timesCalled}']);
+      return Stream.fromIterable(['Called ${++timesCalled}']);
     }
 
     expect(await cache.fetchStream(call).toList(), ['Called 1']);
@@ -136,7 +136,7 @@
   });
 
   test('should cancel a cached stream without affecting others', () async {
-    Stream<String> call() => new Stream.fromIterable(['1', '2', '3']);
+    Stream<String> call() => Stream.fromIterable(['1', '2', '3']);
 
     expect(cache.fetchStream(call).toList(), completion(['1', '2', '3']));
 
@@ -145,7 +145,7 @@
   });
 
   test('should pause a cached stream without affecting others', () async {
-    Stream<String> call() => new Stream.fromIterable(['1', '2', '3']);
+    Stream<String> call() => Stream.fromIterable(['1', '2', '3']);
 
     StreamSubscription sub;
     sub = cache.fetchStream(call).listen(expectAsync1((event) {
diff --git a/test/async_memoizer_test.dart b/test/async_memoizer_test.dart
index 380f58d..785f9a5 100644
--- a/test/async_memoizer_test.dart
+++ b/test/async_memoizer_test.dart
@@ -7,7 +7,7 @@
 
 main() {
   AsyncMemoizer cache;
-  setUp(() => cache = new AsyncMemoizer());
+  setUp(() => cache = AsyncMemoizer());
 
   test("runs the function only the first time runOnce() is called", () async {
     var count = 0;
diff --git a/test/byte_collection_test.dart b/test/byte_collection_test.dart
index b87b074..24d218b 100644
--- a/test/byte_collection_test.dart
+++ b/test/byte_collection_test.dart
@@ -10,7 +10,7 @@
 void main() {
   group("collectBytes", () {
     test("simple list and overflow", () {
-      var result = collectBytes(new Stream.fromIterable([
+      var result = collectBytes(Stream.fromIterable([
         [0],
         [1],
         [2],
@@ -20,25 +20,25 @@
     });
 
     test("no events", () {
-      var result = collectBytes(new Stream.fromIterable([]));
+      var result = collectBytes(Stream.fromIterable([]));
       expect(result, completion([]));
     });
 
     test("empty events", () {
-      var result = collectBytes(new Stream.fromIterable([[], []]));
+      var result = collectBytes(Stream.fromIterable([[], []]));
       expect(result, completion([]));
     });
 
     test("error event", () {
-      var result = collectBytes(new Stream.fromIterable(
-          new Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
+      var result = collectBytes(Stream.fromIterable(
+          Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
       expect(result, throwsA("badness"));
     });
   });
 
   group("collectBytes", () {
     test("simple list and overflow", () {
-      var result = collectBytesCancelable(new Stream.fromIterable([
+      var result = collectBytesCancelable(Stream.fromIterable([
         [0],
         [1],
         [2],
@@ -48,23 +48,23 @@
     });
 
     test("no events", () {
-      var result = collectBytesCancelable(new Stream.fromIterable([]));
+      var result = collectBytesCancelable(Stream.fromIterable([]));
       expect(result.value, completion([]));
     });
 
     test("empty events", () {
-      var result = collectBytesCancelable(new Stream.fromIterable([[], []]));
+      var result = collectBytesCancelable(Stream.fromIterable([[], []]));
       expect(result.value, completion([]));
     });
 
     test("error event", () {
-      var result = collectBytesCancelable(new Stream.fromIterable(
-          new Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
+      var result = collectBytesCancelable(Stream.fromIterable(
+          Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
       expect(result.value, throwsA("badness"));
     });
 
     test("cancelled", () async {
-      var sc = new StreamController<List<int>>();
+      var sc = StreamController<List<int>>();
       var result = collectBytesCancelable(sc.stream);
       // Value never completes.
       result.value.whenComplete(expectAsync0(() {}, count: 0));
@@ -87,4 +87,4 @@
   });
 }
 
-Future nextTimerTick() => new Future(() {});
+Future nextTimerTick() => Future(() {});
diff --git a/test/cancelable_operation_test.dart b/test/cancelable_operation_test.dart
index 8c92e2a..4a23856 100644
--- a/test/cancelable_operation_test.dart
+++ b/test/cancelable_operation_test.dart
@@ -13,8 +13,7 @@
   group("without being canceled", () {
     CancelableCompleter completer;
     setUp(() {
-      completer =
-          new CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
+      completer = CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
     });
 
     test("sends values to the future", () {
@@ -34,14 +33,14 @@
     test("sends values in a future to the future", () {
       expect(completer.operation.value, completion(equals(1)));
       expect(completer.isCompleted, isFalse);
-      completer.complete(new Future.value(1));
+      completer.complete(Future.value(1));
       expect(completer.isCompleted, isTrue);
     });
 
     test("sends errors in a future to the future", () {
       expect(completer.operation.value, throwsA("error"));
       expect(completer.isCompleted, isFalse);
-      completer.complete(new Future.error("error"));
+      completer.complete(Future.error("error"));
       expect(completer.isCompleted, isTrue);
     });
 
@@ -74,31 +73,28 @@
 
       test("successfully then with a future", () {
         completer.complete(1);
-        expect(
-            () => completer.complete(new Completer().future), throwsStateError);
+        expect(() => completer.complete(Completer().future), throwsStateError);
       });
 
       test("with a future then successfully", () {
-        completer.complete(new Completer().future);
+        completer.complete(Completer().future);
         expect(() => completer.complete(1), throwsStateError);
       });
 
       test("with a future twice", () {
-        completer.complete(new Completer().future);
-        expect(
-            () => completer.complete(new Completer().future), throwsStateError);
+        completer.complete(Completer().future);
+        expect(() => completer.complete(Completer().future), throwsStateError);
       });
     });
 
     group("CancelableOperation.fromFuture", () {
       test("forwards values", () {
-        var operation = new CancelableOperation.fromFuture(new Future.value(1));
+        var operation = CancelableOperation.fromFuture(Future.value(1));
         expect(operation.value, completion(equals(1)));
       });
 
       test("forwards errors", () {
-        var operation =
-            new CancelableOperation.fromFuture(new Future.error("error"));
+        var operation = CancelableOperation.fromFuture(Future.error("error"));
         expect(operation.value, throwsA("error"));
       });
     });
@@ -106,7 +102,7 @@
 
   group("when canceled", () {
     test("causes the future never to fire", () async {
-      var completer = new CancelableCompleter();
+      var completer = CancelableCompleter();
       completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
       completer.operation.cancel();
 
@@ -119,7 +115,7 @@
     test("fires onCancel", () {
       var canceled = false;
       CancelableCompleter completer;
-      completer = new CancelableCompleter(onCancel: expectAsync0(() {
+      completer = CancelableCompleter(onCancel: expectAsync0(() {
         expect(completer.isCanceled, isTrue);
         canceled = true;
       }));
@@ -134,8 +130,8 @@
     });
 
     test("returns the onCancel future each time cancel is called", () {
-      var completer = new CancelableCompleter(onCancel: expectAsync0(() {
-        return new Future.value(1);
+      var completer = CancelableCompleter(onCancel: expectAsync0(() {
+        return Future.value(1);
       }));
       expect(completer.operation.cancel(), completion(equals(1)));
       expect(completer.operation.cancel(), completion(equals(1)));
@@ -143,13 +139,13 @@
     });
 
     test("returns a future even if onCancel doesn't", () {
-      var completer = new CancelableCompleter(onCancel: expectAsync0(() {}));
+      var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
       expect(completer.operation.cancel(), completes);
     });
 
     test("doesn't call onCancel if the completer has completed", () {
       var completer =
-          new CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
+          CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
       completer.complete(1);
       expect(completer.operation.value, completion(equals(1)));
       expect(completer.operation.cancel(), completes);
@@ -158,8 +154,8 @@
     test(
         "does call onCancel if the completer has completed to an unfired "
         "Future", () {
-      var completer = new CancelableCompleter(onCancel: expectAsync0(() {}));
-      completer.complete(new Completer().future);
+      var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
+      completer.complete(Completer().future);
       expect(completer.operation.cancel(), completes);
     });
 
@@ -167,14 +163,14 @@
         "doesn't call onCancel if the completer has completed to a fired "
         "Future", () async {
       var completer =
-          new CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
-      completer.complete(new Future.value(1));
+          CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
+      completer.complete(Future.value(1));
       await completer.operation.value;
       expect(completer.operation.cancel(), completes);
     });
 
     test("can be completed once after being canceled", () async {
-      var completer = new CancelableCompleter();
+      var completer = CancelableCompleter();
       completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
       await completer.operation.cancel();
       completer.complete(1);
@@ -182,13 +178,13 @@
     });
 
     test("fires valueOrCancellation with the given value", () {
-      var completer = new CancelableCompleter();
+      var completer = CancelableCompleter();
       expect(completer.operation.valueOrCancellation(1), completion(equals(1)));
       completer.operation.cancel();
     });
 
     test("pipes an error through valueOrCancellation", () {
-      var completer = new CancelableCompleter(onCancel: () {
+      var completer = CancelableCompleter(onCancel: () {
         throw "error";
       });
       expect(completer.operation.valueOrCancellation(1), throwsA("error"));
@@ -196,9 +192,9 @@
     });
 
     test("valueOrCancellation waits on the onCancel future", () async {
-      var innerCompleter = new Completer();
+      var innerCompleter = Completer();
       var completer =
-          new CancelableCompleter(onCancel: () => innerCompleter.future);
+          CancelableCompleter(onCancel: () => innerCompleter.future);
 
       var fired = false;
       completer.operation.valueOrCancellation().then((_) {
@@ -217,21 +213,21 @@
 
   group("asStream()", () {
     test("emits a value and then closes", () {
-      var completer = new CancelableCompleter();
+      var completer = CancelableCompleter();
       expect(completer.operation.asStream().toList(), completion(equals([1])));
       completer.complete(1);
     });
 
     test("emits an error and then closes", () {
-      var completer = new CancelableCompleter();
-      var queue = new StreamQueue(completer.operation.asStream());
+      var completer = CancelableCompleter();
+      var queue = StreamQueue(completer.operation.asStream());
       expect(queue.next, throwsA("error"));
       expect(queue.hasNext, completion(isFalse));
       completer.completeError("error");
     });
 
     test("cancels the completer when the subscription is canceled", () {
-      var completer = new CancelableCompleter(onCancel: expectAsync0(() {}));
+      var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
       var sub =
           completer.operation.asStream().listen(expectAsync1((_) {}, count: 0));
       completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
diff --git a/test/future_group_test.dart b/test/future_group_test.dart
index b6f75ba..770a465 100644
--- a/test/future_group_test.dart
+++ b/test/future_group_test.dart
@@ -12,7 +12,7 @@
 void main() {
   FutureGroup futureGroup;
   setUp(() {
-    futureGroup = new FutureGroup();
+    futureGroup = FutureGroup();
   });
 
   group("with no futures", () {
@@ -32,7 +32,7 @@
 
   group("with a future that already completed", () {
     test("never completes if nothing happens", () async {
-      futureGroup.add(new Future.value());
+      futureGroup.add(Future.value());
       await flushMicrotasks();
 
       var completed = false;
@@ -43,7 +43,7 @@
     });
 
     test("completes once it's closed", () async {
-      futureGroup.add(new Future.value());
+      futureGroup.add(Future.value());
       await flushMicrotasks();
 
       expect(futureGroup.future, completes);
@@ -51,21 +51,21 @@
     });
 
     test("completes to that future's value", () {
-      futureGroup.add(new Future.value(1));
+      futureGroup.add(Future.value(1));
       futureGroup.close();
       expect(futureGroup.future, completion(equals([1])));
     });
 
     test("completes to that future's error, even if it's not closed", () {
-      futureGroup.add(new Future.error("error"));
+      futureGroup.add(Future.error("error"));
       expect(futureGroup.future, throwsA("error"));
     });
   });
 
   test("completes once all contained futures complete", () async {
-    var completer1 = new Completer();
-    var completer2 = new Completer();
-    var completer3 = new Completer();
+    var completer1 = Completer();
+    var completer2 = Completer();
+    var completer3 = Completer();
 
     futureGroup.add(completer1.future);
     futureGroup.add(completer2.future);
@@ -89,9 +89,9 @@
   });
 
   test("completes to the values of the futures in order of addition", () {
-    var completer1 = new Completer();
-    var completer2 = new Completer();
-    var completer3 = new Completer();
+    var completer1 = Completer();
+    var completer2 = Completer();
+    var completer3 = Completer();
 
     futureGroup.add(completer1.future);
     futureGroup.add(completer2.future);
@@ -108,9 +108,9 @@
 
   test("completes to the first error to be emitted, even if it's not closed",
       () {
-    var completer1 = new Completer();
-    var completer2 = new Completer();
-    var completer3 = new Completer();
+    var completer1 = Completer();
+    var completer2 = Completer();
+    var completer3 = Completer();
 
     futureGroup.add(completer1.future);
     futureGroup.add(completer2.future);
@@ -126,9 +126,9 @@
       var idle = false;
       futureGroup.onIdle.listen((_) => idle = true);
 
-      var completer1 = new Completer();
-      var completer2 = new Completer();
-      var completer3 = new Completer();
+      var completer1 = Completer();
+      var completer2 = Completer();
+      var completer3 = Completer();
 
       futureGroup.add(completer1.future);
       futureGroup.add(completer2.future);
@@ -158,7 +158,7 @@
       var idle = false;
       futureGroup.onIdle.listen((_) => idle = true);
 
-      var completer = new Completer();
+      var completer = Completer();
       futureGroup.add(completer.future);
 
       completer.complete();
@@ -167,7 +167,7 @@
       expect(futureGroup.isIdle, isTrue);
 
       idle = false;
-      completer = new Completer();
+      completer = Completer();
       futureGroup.add(completer.future);
 
       await flushMicrotasks();
@@ -202,7 +202,7 @@
         futureFired = true;
       }));
 
-      var completer = new Completer();
+      var completer = Completer();
       futureGroup.add(completer.future);
       futureGroup.close();
 
diff --git a/test/lazy_stream_test.dart b/test/lazy_stream_test.dart
index 0c2e344..db1bc94 100644
--- a/test/lazy_stream_test.dart
+++ b/test/lazy_stream_test.dart
@@ -11,14 +11,14 @@
 
 main() {
   test("disallows a null callback", () {
-    expect(() => new LazyStream(null), throwsArgumentError);
+    expect(() => LazyStream(null), throwsArgumentError);
   });
 
   test("calls the callback when the stream is listened", () async {
     var callbackCalled = false;
-    var stream = new LazyStream(expectAsync0(() {
+    var stream = LazyStream(expectAsync0(() {
       callbackCalled = true;
-      return new Stream.empty();
+      return Stream.empty();
     }));
 
     await flushMicrotasks();
@@ -30,9 +30,9 @@
 
   test("calls the callback when the stream is listened", () async {
     var callbackCalled = false;
-    var stream = new LazyStream(expectAsync0(() {
+    var stream = LazyStream(expectAsync0(() {
       callbackCalled = true;
-      return new Stream.empty();
+      return Stream.empty();
     }));
 
     await flushMicrotasks();
@@ -43,8 +43,8 @@
   });
 
   test("forwards to a synchronously-provided stream", () async {
-    var controller = new StreamController<int>();
-    var stream = new LazyStream(expectAsync0(() => controller.stream));
+    var controller = StreamController<int>();
+    var stream = LazyStream(expectAsync0(() => controller.stream));
 
     var events = [];
     stream.listen(events.add);
@@ -65,8 +65,8 @@
   });
 
   test("forwards to an asynchronously-provided stream", () async {
-    var controller = new StreamController<int>();
-    var stream = new LazyStream(expectAsync0(() async => controller.stream));
+    var controller = StreamController<int>();
+    var stream = LazyStream(expectAsync0(() async => controller.stream));
 
     var events = [];
     stream.listen(events.add);
@@ -87,7 +87,7 @@
   });
 
   test("a lazy stream can't be listened to multiple times", () {
-    var stream = new LazyStream(expectAsync0(() => new Stream.empty()));
+    var stream = LazyStream(expectAsync0(() => Stream.empty()));
     expect(stream.isBroadcast, isFalse);
 
     stream.listen(null);
@@ -97,9 +97,9 @@
 
   test("a lazy stream can't be listened to from within its callback", () {
     LazyStream stream;
-    stream = new LazyStream(expectAsync0(() {
+    stream = LazyStream(expectAsync0(() {
       expect(() => stream.listen(null), throwsStateError);
-      return new Stream.empty();
+      return Stream.empty();
     }));
     stream.listen(null);
   });
diff --git a/test/null_stream_sink_test.dart b/test/null_stream_sink_test.dart
index 244f99c..33e2655 100644
--- a/test/null_stream_sink_test.dart
+++ b/test/null_stream_sink_test.dart
@@ -12,13 +12,13 @@
 void main() {
   group("constructors", () {
     test("done defaults to a completed future", () {
-      var sink = new NullStreamSink();
+      var sink = NullStreamSink();
       expect(sink.done, completes);
     });
 
     test("a custom future may be passed to done", () async {
-      var completer = new Completer();
-      var sink = new NullStreamSink(done: completer.future);
+      var completer = Completer();
+      var sink = NullStreamSink(done: completer.future);
 
       var doneFired = false;
       sink.done.then((_) {
@@ -33,32 +33,32 @@
     });
 
     test("NullStreamSink.error passes an error to done", () {
-      var sink = new NullStreamSink.error("oh no");
+      var sink = NullStreamSink.error("oh no");
       expect(sink.done, throwsA("oh no"));
     });
   });
 
   group("events", () {
     test("are silently dropped before close", () {
-      var sink = new NullStreamSink();
+      var sink = NullStreamSink();
       sink.add(1);
       sink.addError("oh no");
     });
 
     test("throw StateErrors after close", () {
-      var sink = new NullStreamSink();
+      var sink = NullStreamSink();
       expect(sink.close(), completes);
 
       expect(() => sink.add(1), throwsStateError);
       expect(() => sink.addError("oh no"), throwsStateError);
-      expect(() => sink.addStream(new Stream.empty()), throwsStateError);
+      expect(() => sink.addStream(Stream.empty()), throwsStateError);
     });
 
     group("addStream", () {
       test("listens to the stream then cancels immediately", () async {
-        var sink = new NullStreamSink();
+        var sink = NullStreamSink();
         var canceled = false;
-        var controller = new StreamController(onCancel: () {
+        var controller = StreamController(onCancel: () {
           canceled = true;
         });
 
@@ -68,9 +68,9 @@
       });
 
       test("returns the cancel future", () async {
-        var completer = new Completer();
-        var sink = new NullStreamSink();
-        var controller = new StreamController(onCancel: () => completer.future);
+        var completer = Completer();
+        var sink = NullStreamSink();
+        var controller = StreamController(onCancel: () => completer.future);
 
         var addStreamFired = false;
         sink.addStream(controller.stream).then((_) {
@@ -85,29 +85,29 @@
       });
 
       test("pipes errors from the cancel future through addStream", () async {
-        var sink = new NullStreamSink();
-        var controller = new StreamController(onCancel: () => throw "oh no");
+        var sink = NullStreamSink();
+        var controller = StreamController(onCancel: () => throw "oh no");
         expect(sink.addStream(controller.stream), throwsA("oh no"));
       });
 
       test("causes events to throw StateErrors until the future completes",
           () async {
-        var sink = new NullStreamSink();
-        var future = sink.addStream(new Stream.empty());
+        var sink = NullStreamSink();
+        var future = sink.addStream(Stream.empty());
         expect(() => sink.add(1), throwsStateError);
         expect(() => sink.addError("oh no"), throwsStateError);
-        expect(() => sink.addStream(new Stream.empty()), throwsStateError);
+        expect(() => sink.addStream(Stream.empty()), throwsStateError);
 
         await future;
         sink.add(1);
         sink.addError("oh no");
-        expect(sink.addStream(new Stream.empty()), completes);
+        expect(sink.addStream(Stream.empty()), completes);
       });
     });
   });
 
   test("close returns the done future", () {
-    var sink = new NullStreamSink.error("oh no");
+    var sink = NullStreamSink.error("oh no");
     expect(sink.close(), throwsA("oh no"));
   });
 }
diff --git a/test/restartable_timer_test.dart b/test/restartable_timer_test.dart
index 4f59f62..c46c87b 100644
--- a/test/restartable_timer_test.dart
+++ b/test/restartable_timer_test.dart
@@ -8,100 +8,99 @@
 
 main() {
   test("runs the callback once the duration has elapsed", () {
-    new FakeAsync().run((async) {
+    FakeAsync().run((async) {
       var fired = false;
-      new RestartableTimer(new Duration(seconds: 5), () {
+      RestartableTimer(Duration(seconds: 5), () {
         fired = true;
       });
 
-      async.elapse(new Duration(seconds: 4));
+      async.elapse(Duration(seconds: 4));
       expect(fired, isFalse);
 
-      async.elapse(new Duration(seconds: 1));
+      async.elapse(Duration(seconds: 1));
       expect(fired, isTrue);
     });
   });
 
   test("doesn't run the callback if the timer is canceled", () {
-    new FakeAsync().run((async) {
+    FakeAsync().run((async) {
       var fired = false;
-      var timer = new RestartableTimer(new Duration(seconds: 5), () {
+      var timer = RestartableTimer(Duration(seconds: 5), () {
         fired = true;
       });
 
-      async.elapse(new Duration(seconds: 4));
+      async.elapse(Duration(seconds: 4));
       expect(fired, isFalse);
       timer.cancel();
 
-      async.elapse(new Duration(seconds: 4));
+      async.elapse(Duration(seconds: 4));
       expect(fired, isFalse);
     });
   });
 
   test("resets the duration if the timer is reset before it fires", () {
-    new FakeAsync().run((async) {
+    FakeAsync().run((async) {
       var fired = false;
-      var timer = new RestartableTimer(new Duration(seconds: 5), () {
+      var timer = RestartableTimer(Duration(seconds: 5), () {
         fired = true;
       });
 
-      async.elapse(new Duration(seconds: 4));
+      async.elapse(Duration(seconds: 4));
       expect(fired, isFalse);
       timer.reset();
 
-      async.elapse(new Duration(seconds: 4));
+      async.elapse(Duration(seconds: 4));
       expect(fired, isFalse);
 
-      async.elapse(new Duration(seconds: 1));
+      async.elapse(Duration(seconds: 1));
       expect(fired, isTrue);
     });
   });
 
   test("re-runs the callback if the timer is reset after firing", () {
-    new FakeAsync().run((async) {
+    FakeAsync().run((async) {
       var fired = 0;
-      var timer = new RestartableTimer(new Duration(seconds: 5), () {
+      var timer = RestartableTimer(Duration(seconds: 5), () {
         fired++;
       });
 
-      async.elapse(new Duration(seconds: 5));
+      async.elapse(Duration(seconds: 5));
       expect(fired, equals(1));
       timer.reset();
 
-      async.elapse(new Duration(seconds: 5));
+      async.elapse(Duration(seconds: 5));
       expect(fired, equals(2));
       timer.reset();
 
-      async.elapse(new Duration(seconds: 5));
+      async.elapse(Duration(seconds: 5));
       expect(fired, equals(3));
     });
   });
 
   test("runs the callback if the timer is reset after being canceled", () {
-    new FakeAsync().run((async) {
+    FakeAsync().run((async) {
       var fired = false;
-      var timer = new RestartableTimer(new Duration(seconds: 5), () {
+      var timer = RestartableTimer(Duration(seconds: 5), () {
         fired = true;
       });
 
-      async.elapse(new Duration(seconds: 4));
+      async.elapse(Duration(seconds: 4));
       expect(fired, isFalse);
       timer.cancel();
 
-      async.elapse(new Duration(seconds: 4));
+      async.elapse(Duration(seconds: 4));
       expect(fired, isFalse);
       timer.reset();
 
-      async.elapse(new Duration(seconds: 5));
+      async.elapse(Duration(seconds: 5));
       expect(fired, isTrue);
     });
   });
 
   test("only runs the callback once if the timer isn't reset", () {
-    new FakeAsync().run((async) {
-      new RestartableTimer(
-          new Duration(seconds: 5), expectAsync0(() {}, count: 1));
-      async.elapse(new Duration(seconds: 10));
+    FakeAsync().run((async) {
+      RestartableTimer(Duration(seconds: 5), expectAsync0(() {}, count: 1));
+      async.elapse(Duration(seconds: 10));
     });
   });
 }
diff --git a/test/result/result_captureAll_test.dart b/test/result/result_captureAll_test.dart
index 172e38a..c7b688f 100644
--- a/test/result/result_captureAll_test.dart
+++ b/test/result/result_captureAll_test.dart
@@ -8,16 +8,16 @@
 import "package:test/test.dart";
 
 final someStack = StackTrace.current;
-Result<int> res(int n) => new Result<int>.value(n);
-Result err(n) => new ErrorResult("$n", someStack);
+Result<int> res(int n) => Result<int>.value(n);
+Result err(n) => ErrorResult("$n", someStack);
 
 /// Helper function creating an iterable of futures.
 Iterable<Future<int>> futures(int count, {bool throwWhen(int index)}) sync* {
   for (int i = 0; i < count; i++) {
     if (throwWhen != null && throwWhen(i)) {
-      yield new Future<int>.error("$i", someStack);
+      yield Future<int>.error("$i", someStack);
     } else {
-      yield new Future<int>.value(i);
+      yield Future<int>.value(i);
     }
   }
 }
@@ -58,7 +58,7 @@
     });
 
     test("completion permutation 1-2-3", () async {
-      var cs = new List.generate(3, (_) => new Completer<int>());
+      var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
@@ -70,7 +70,7 @@
     });
 
     test("completion permutation 1-3-2", () async {
-      var cs = new List.generate(3, (_) => new Completer<int>());
+      var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
@@ -82,7 +82,7 @@
     });
 
     test("completion permutation 2-1-3", () async {
-      var cs = new List.generate(3, (_) => new Completer<int>());
+      var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
@@ -94,7 +94,7 @@
     });
 
     test("completion permutation 2-3-1", () async {
-      var cs = new List.generate(3, (_) => new Completer<int>());
+      var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
@@ -106,7 +106,7 @@
     });
 
     test("completion permutation 3-1-2", () async {
-      var cs = new List.generate(3, (_) => new Completer<int>());
+      var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
@@ -118,7 +118,7 @@
     });
 
     test("completion permutation 3-2-1", () async {
-      var cs = new List.generate(3, (_) => new Completer<int>());
+      var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
@@ -129,19 +129,19 @@
       cs[0].complete(1);
     });
 
-    var seed = new Random().nextInt(0x100000000);
+    var seed = Random().nextInt(0x100000000);
     int n = 25; // max 32, otherwise rnd.nextInt(1<<n) won't work.
     test("randomized #$n seed:${seed.toRadixString(16)}", () async {
-      var cs = new List.generate(n, (_) => new Completer<int>());
+      var cs = List.generate(n, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
-      var rnd = new Random(seed);
+      var rnd = Random(seed);
       var throwFlags = rnd.nextInt(1 << n); // Bit-flag for throwing.
       bool throws(index) => (throwFlags & (1 << index)) != 0;
-      var expected = new List.generate(n, (x) => throws(x) ? err(x) : res(x));
+      var expected = List.generate(n, (x) => throws(x) ? err(x) : res(x));
 
       expect(all, completion(expected));
 
-      var completeFunctions = new List<Function()>.generate(n, (i) {
+      var completeFunctions = List<Function()>.generate(n, (i) {
         var c = cs[i];
         return () =>
             throws(i) ? c.completeError("$i", someStack) : c.complete(i);
@@ -167,19 +167,19 @@
     test("no error", () async {
       var all = await Result.captureAll<int>(<FutureOr<int>>[
         1,
-        new Future<int>(() => 2),
+        Future<int>(() => 2),
         3,
-        new Future<int>.value(4),
+        Future<int>.value(4),
       ]);
       expect(all, [res(1), res(2), res(3), res(4)]);
     });
     test("error", () async {
       var all = await Result.captureAll<int>(<FutureOr<int>>[
         1,
-        new Future<int>(() => 2),
+        Future<int>(() => 2),
         3,
-        new Future<int>(() async => await new Future.error("4", someStack)),
-        new Future<int>.value(5)
+        Future<int>(() async => await Future.error("4", someStack)),
+        Future<int>.value(5)
       ]);
       expect(all, [res(1), res(2), res(3), err(4), res(5)]);
     });
diff --git a/test/result/result_flattenAll_test.dart b/test/result/result_flattenAll_test.dart
index caaf668..4a049eb 100644
--- a/test/result/result_flattenAll_test.dart
+++ b/test/result/result_flattenAll_test.dart
@@ -6,8 +6,8 @@
 import "package:test/test.dart";
 
 final someStack = StackTrace.current;
-Result<T> res<T>(T n) => new Result<T>.value(n);
-Result err(n) => new ErrorResult("$n", someStack);
+Result<T> res<T>(T n) => Result<T>.value(n);
+Result err(n) => ErrorResult("$n", someStack);
 
 /// Helper function creating an iterable of results.
 Iterable<Result<int>> results(int count, {bool throwWhen(int index)}) sync* {
diff --git a/test/result/result_future_test.dart b/test/result/result_future_test.dart
index ffdbb7c..4218db2 100644
--- a/test/result/result_future_test.dart
+++ b/test/result/result_future_test.dart
@@ -12,8 +12,8 @@
   Completer completer;
   ResultFuture future;
   setUp(() {
-    completer = new Completer();
-    future = new ResultFuture(completer.future);
+    completer = Completer();
+    future = ResultFuture(completer.future);
   });
 
   test('before completion, result is null', () {
@@ -30,7 +30,7 @@
   });
 
   test("after an error completion, result is the future's error", () {
-    var trace = new Trace.current();
+    var trace = Trace.current();
     completer.completeError('error', trace);
 
     // The completer calls its listeners asynchronously. We have to wait
diff --git a/test/result/result_test.dart b/test/result/result_test.dart
index 33e146e..a33c1ba 100644
--- a/test/result/result_test.dart
+++ b/test/result/result_test.dart
@@ -10,10 +10,10 @@
 import "package:test/test.dart";
 
 void main() {
-  var stack = new Trace.current();
+  var stack = Trace.current();
 
   test("create result value", () {
-    Result<int> result = new Result<int>.value(42);
+    Result<int> result = Result<int>.value(42);
     expect(result.isValue, isTrue);
     expect(result.isError, isFalse);
     ValueResult value = result.asValue;
@@ -21,7 +21,7 @@
   });
 
   test("create result value 2", () {
-    Result<int> result = new ValueResult<int>(42);
+    Result<int> result = ValueResult<int>(42);
     expect(result.isValue, isTrue);
     expect(result.isError, isFalse);
     ValueResult<int> value = result.asValue;
@@ -29,7 +29,7 @@
   });
 
   test("create result error", () {
-    Result<bool> result = new Result<bool>.error("BAD", stack);
+    Result<bool> result = Result<bool>.error("BAD", stack);
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
     ErrorResult error = result.asError;
@@ -38,7 +38,7 @@
   });
 
   test("create result error 2", () {
-    Result<bool> result = new ErrorResult("BAD", stack);
+    Result<bool> result = ErrorResult("BAD", stack);
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
     ErrorResult error = result.asError;
@@ -47,7 +47,7 @@
   });
 
   test("create result error no stack", () {
-    Result<bool> result = new Result<bool>.error("BAD");
+    Result<bool> result = Result<bool>.error("BAD");
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
     ErrorResult error = result.asError;
@@ -56,8 +56,8 @@
   });
 
   test("complete with value", () {
-    Result<int> result = new ValueResult<int>(42);
-    var c = new Completer<int>();
+    Result<int> result = ValueResult<int>(42);
+    var c = Completer<int>();
     c.future.then(expectAsync1((int v) {
       expect(v, equals(42));
     }), onError: (e, s) {
@@ -67,8 +67,8 @@
   });
 
   test("complete with error", () {
-    Result<bool> result = new ErrorResult("BAD", stack);
-    var c = new Completer<bool>();
+    Result<bool> result = ErrorResult("BAD", stack);
+    var c = Completer<bool>();
     c.future.then((bool v) {
       fail("Unexpected value $v");
     }, onError: expectAsync2((e, s) {
@@ -79,16 +79,16 @@
   });
 
   test("add sink value", () {
-    var result = new ValueResult<int>(42);
-    EventSink<int> sink = new TestSink(onData: expectAsync1((v) {
+    var result = ValueResult<int>(42);
+    EventSink<int> sink = TestSink(onData: expectAsync1((v) {
       expect(v, equals(42));
     }));
     result.addTo(sink);
   });
 
   test("add sink error", () {
-    Result<bool> result = new ErrorResult("BAD", stack);
-    EventSink<bool> sink = new TestSink(onError: expectAsync2((e, s) {
+    Result<bool> result = ErrorResult("BAD", stack);
+    EventSink<bool> sink = TestSink(onError: expectAsync2((e, s) {
       expect(e, equals("BAD"));
       expect(s, same(stack));
     }));
@@ -96,7 +96,7 @@
   });
 
   test("value as future", () {
-    Result<int> result = new ValueResult<int>(42);
+    Result<int> result = ValueResult<int>(42);
     result.asFuture.then(expectAsync1((int v) {
       expect(v, equals(42));
     }), onError: (e, s) {
@@ -105,7 +105,7 @@
   });
 
   test("error as future", () {
-    Result<bool> result = new ErrorResult("BAD", stack);
+    Result<bool> result = ErrorResult("BAD", stack);
     result.asFuture.then((bool v) {
       fail("Unexpected value $v");
     }, onError: expectAsync2((e, s) {
@@ -115,7 +115,7 @@
   });
 
   test("capture future value", () {
-    Future<int> value = new Future<int>.value(42);
+    Future<int> value = Future<int>.value(42);
     Result.capture(value).then(expectAsync1((Result result) {
       expect(result.isValue, isTrue);
       expect(result.isError, isFalse);
@@ -127,7 +127,7 @@
   });
 
   test("capture future error", () {
-    Future<bool> value = new Future<bool>.error("BAD", stack);
+    Future<bool> value = Future<bool>.error("BAD", stack);
     Result.capture(value).then(expectAsync1((Result result) {
       expect(result.isValue, isFalse);
       expect(result.isError, isTrue);
@@ -141,7 +141,7 @@
 
   test("release future value", () {
     Future<Result<int>> future =
-        new Future<Result<int>>.value(new Result<int>.value(42));
+        Future<Result<int>>.value(Result<int>.value(42));
     Result.release(future).then(expectAsync1((v) {
       expect(v, equals(42));
     }), onError: (e, s) {
@@ -152,7 +152,7 @@
   test("release future error", () {
     // An error in the result is unwrapped and reified by release.
     Future<Result<bool>> future =
-        new Future<Result<bool>>.value(new Result<bool>.error("BAD", stack));
+        Future<Result<bool>>.value(Result<bool>.error("BAD", stack));
     Result.release(future).then((v) {
       fail("Unexpected value: $v");
     }, onError: expectAsync2((e, s) {
@@ -163,7 +163,7 @@
 
   test("release future real error", () {
     // An error in the error lane is passed through by release.
-    Future<Result<bool>> future = new Future<Result<bool>>.error("BAD", stack);
+    Future<Result<bool>> future = Future<Result<bool>>.error("BAD", stack);
     Result.release(future).then((v) {
       fail("Unexpected value: $v");
     }, onError: expectAsync2((e, s) {
@@ -173,13 +173,10 @@
   });
 
   test("capture stream", () {
-    var c = new StreamController<int>();
+    var c = StreamController<int>();
     var stream = Result.captureStream(c.stream);
-    var expectedList = new Queue.from([
-      new Result.value(42),
-      new Result.error("BAD", stack),
-      new Result.value(37)
-    ]);
+    var expectedList = Queue.from(
+        [Result.value(42), Result.error("BAD", stack), Result.value(37)]);
     void listener(Result actual) {
       expect(expectedList.isEmpty, isFalse);
       expectResult(actual, expectedList.removeFirst());
@@ -194,16 +191,15 @@
   });
 
   test("release stream", () {
-    StreamController<Result<int>> c = new StreamController<Result<int>>();
+    StreamController<Result<int>> c = StreamController<Result<int>>();
     Stream<int> stream = Result.releaseStream(c.stream);
     var events = [
-      new Result<int>.value(42),
-      new Result<int>.error("BAD", stack),
-      new Result<int>.value(37)
+      Result<int>.value(42),
+      Result<int>.error("BAD", stack),
+      Result<int>.value(37)
     ];
     // Expect the data events, and an extra error event.
-    var expectedList = new Queue.from(events)
-      ..add(new Result.error("BAD2", stack));
+    var expectedList = Queue.from(events)..add(Result.error("BAD2", stack));
 
     void dataListener(int v) {
       expect(expectedList.isEmpty, isFalse);
@@ -231,7 +227,7 @@
   });
 
   test("release stream cancel on error", () {
-    StreamController<Result<int>> c = new StreamController<Result<int>>();
+    StreamController<Result<int>> c = StreamController<Result<int>>();
     Stream<int> stream = Result.releaseStream(c.stream);
     stream.listen(expectAsync1((v) {
       expect(v, equals(42));
@@ -241,34 +237,34 @@
     }), onDone: () {
       fail("Unexpected done event");
     }, cancelOnError: true);
-    c.add(new Result.value(42));
-    c.add(new Result.error("BAD", stack));
-    c.add(new Result.value(37));
+    c.add(Result.value(42));
+    c.add(Result.error("BAD", stack));
+    c.add(Result.value(37));
     c.close();
   });
 
   test("flatten error 1", () {
-    Result<int> error = new Result<int>.error("BAD", stack);
+    Result<int> error = Result<int>.error("BAD", stack);
     Result<int> flattened =
-        Result.flatten(new Result<Result<int>>.error("BAD", stack));
+        Result.flatten(Result<Result<int>>.error("BAD", stack));
     expectResult(flattened, error);
   });
 
   test("flatten error 2", () {
-    Result<int> error = new Result<int>.error("BAD", stack);
-    Result<Result<int>> result = new Result<Result<int>>.value(error);
+    Result<int> error = Result<int>.error("BAD", stack);
+    Result<Result<int>> result = Result<Result<int>>.value(error);
     Result<int> flattened = Result.flatten(result);
     expectResult(flattened, error);
   });
 
   test("flatten value", () {
     Result<Result<int>> result =
-        new Result<Result<int>>.value(new Result<int>.value(42));
-    expectResult(Result.flatten(result), new Result<int>.value(42));
+        Result<Result<int>>.value(Result<int>.value(42));
+    expectResult(Result.flatten(result), Result<int>.value(42));
   });
 
   test("handle unary", () {
-    ErrorResult result = new Result.error("error", stack);
+    ErrorResult result = Result.error("error", stack);
     bool called = false;
     result.handle((error) {
       called = true;
@@ -278,7 +274,7 @@
   });
 
   test("handle binary", () {
-    ErrorResult result = new Result.error("error", stack);
+    ErrorResult result = Result.error("error", stack);
     bool called = false;
     result.handle((error, stackTrace) {
       called = true;
@@ -289,7 +285,7 @@
   });
 
   test("handle unary and binary", () {
-    ErrorResult result = new Result.error("error", stack);
+    ErrorResult result = Result.error("error", stack);
     bool called = false;
     result.handle((error, [stackTrace]) {
       called = true;
@@ -300,7 +296,7 @@
   });
 
   test("handle neither unary nor binary", () {
-    ErrorResult result = new Result.error("error", stack);
+    ErrorResult result = Result.error("error", stack);
     expect(() => result.handle(() => fail("unreachable")), throwsA(anything));
     expect(() => result.handle((a, b, c) => fail("unreachable")),
         throwsA(anything));
@@ -332,9 +328,9 @@
   final Function onDone;
 
   TestSink(
-      {void this.onData(T data): _nullData,
-      void this.onError(e, StackTrace s): _nullError,
-      void this.onDone(): _nullDone});
+      {void this.onData(T data) = _nullData,
+      void this.onError(e, StackTrace s) = _nullError,
+      void this.onDone() = _nullDone});
 
   void add(T value) {
     onData(value);
diff --git a/test/single_subscription_transformer_test.dart b/test/single_subscription_transformer_test.dart
index 74e462b..95b321b 100644
--- a/test/single_subscription_transformer_test.dart
+++ b/test/single_subscription_transformer_test.dart
@@ -11,7 +11,7 @@
 
 void main() {
   test("buffers events as soon as it's bound", () async {
-    var controller = new StreamController.broadcast();
+    var controller = StreamController.broadcast();
     var stream =
         controller.stream.transform(const SingleSubscriptionTransformer());
 
@@ -31,7 +31,7 @@
   test("cancels the subscription to the broadcast stream when it's canceled",
       () async {
     var canceled = false;
-    var controller = new StreamController.broadcast(onCancel: () {
+    var controller = StreamController.broadcast(onCancel: () {
       canceled = true;
     });
     var stream =
diff --git a/test/stream_completer_test.dart b/test/stream_completer_test.dart
index 55b4ce3..fb1f4a5 100644
--- a/test/stream_completer_test.dart
+++ b/test/stream_completer_test.dart
@@ -11,13 +11,13 @@
 
 main() {
   test("a stream is linked before listening", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     completer.setSourceStream(createStream());
     expect(completer.stream.toList(), completion([1, 2, 3, 4]));
   });
 
   test("listened to before a stream is linked", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     var done = completer.stream.toList();
     await flushMicrotasks();
     completer.setSourceStream(createStream());
@@ -25,20 +25,20 @@
   });
 
   test("cancel before linking a stream doesn't listen on stream", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     var subscription = completer.stream.listen(null);
     subscription.pause(); // Should be ignored.
     subscription.cancel();
-    completer.setSourceStream(new UnusableStream()); // Doesn't throw.
+    completer.setSourceStream(UnusableStream()); // Doesn't throw.
   });
 
   test("listen and pause before linking stream", () async {
-    var controller = new StreamCompleter();
+    var controller = StreamCompleter();
     var events = [];
     var subscription = controller.stream.listen(events.add);
     var done = subscription.asFuture();
     subscription.pause();
-    var sourceController = new StreamController();
+    var sourceController = StreamController();
     sourceController..add(1)..add(2)..add(3)..add(4);
     controller.setSourceStream(sourceController.stream);
     await flushMicrotasks();
@@ -56,7 +56,7 @@
   });
 
   test("pause more than once", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     var events = [];
     var subscription = completer.stream.listen(events.add);
     var done = subscription.asFuture();
@@ -74,9 +74,9 @@
   });
 
   test("cancel new stream before source is done", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     var lastEvent = -1;
-    var controller = new StreamController();
+    var controller = StreamController();
     StreamSubscription subscription;
     subscription = completer.stream.listen((value) {
       expect(value, lessThan(3));
@@ -106,17 +106,17 @@
   });
 
   test("complete with setEmpty before listening", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     completer.setEmpty();
-    var done = new Completer();
+    var done = Completer();
     completer.stream.listen(unreachable("data"),
         onError: unreachable("error"), onDone: done.complete);
     await done.future;
   });
 
   test("complete with setEmpty after listening", () async {
-    var completer = new StreamCompleter();
-    var done = new Completer();
+    var completer = StreamCompleter();
+    var done = Completer();
     completer.stream.listen(unreachable("data"),
         onError: unreachable("error"), onDone: done.complete);
     completer.setEmpty();
@@ -124,9 +124,9 @@
   });
 
   test("source stream isn't listened to until completer stream is", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     StreamController controller;
-    controller = new StreamController(onListen: () {
+    controller = StreamController(onListen: () {
       scheduleMicrotask(controller.close);
     });
 
@@ -139,9 +139,9 @@
   });
 
   test("cancelOnError true when listening before linking stream", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     Object lastEvent = -1;
-    var controller = new StreamController();
+    var controller = StreamController();
     completer.stream.listen((value) {
       expect(value, lessThan(3));
       lastEvent = value;
@@ -172,9 +172,9 @@
   });
 
   test("cancelOnError true when listening after linking stream", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     Object lastEvent = -1;
-    var controller = new StreamController();
+    var controller = StreamController();
     completer.setSourceStream(controller.stream);
     controller.add(1);
     expect(controller.hasListener, isFalse);
@@ -204,7 +204,7 @@
   });
 
   test("linking a stream after setSourceStream before listen", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     completer.setSourceStream(createStream());
     expect(() => completer.setSourceStream(createStream()), throwsStateError);
     expect(() => completer.setEmpty(), throwsStateError);
@@ -215,7 +215,7 @@
   });
 
   test("linking a stream after setSourceStream after listen", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     var list = completer.stream.toList();
     completer.setSourceStream(createStream());
     expect(() => completer.setSourceStream(createStream()), throwsStateError);
@@ -227,7 +227,7 @@
   });
 
   test("linking a stream after setEmpty before listen", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     completer.setEmpty();
     expect(() => completer.setSourceStream(createStream()), throwsStateError);
     expect(() => completer.setEmpty(), throwsStateError);
@@ -238,7 +238,7 @@
   });
 
   test("linking a stream after setEmpty() after listen", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     var list = completer.stream.toList();
     completer.setEmpty();
     expect(() => completer.setSourceStream(createStream()), throwsStateError);
@@ -250,7 +250,7 @@
   });
 
   test("listening more than once after setting stream", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     completer.setSourceStream(createStream());
     var list = completer.stream.toList();
     expect(() => completer.stream.toList(), throwsStateError);
@@ -259,14 +259,14 @@
   });
 
   test("listening more than once before setting stream", () async {
-    var completer = new StreamCompleter();
+    var completer = StreamCompleter();
     completer.stream.toList();
     expect(() => completer.stream.toList(), throwsStateError);
   });
 
   test("setting onData etc. before and after setting stream", () async {
-    var completer = new StreamCompleter();
-    var controller = new StreamController();
+    var completer = StreamCompleter();
+    var controller = StreamController();
     var subscription = completer.stream.listen(null);
     Object lastEvent = 0;
     subscription.onData((value) => lastEvent = value);
@@ -294,8 +294,8 @@
   });
 
   test("pause w/ resume future accross setting stream", () async {
-    var completer = new StreamCompleter();
-    var resume = new Completer();
+    var completer = StreamCompleter();
+    var resume = Completer();
     var subscription = completer.stream.listen(unreachable("data"));
     subscription.pause(resume.future);
     await flushMicrotasks();
@@ -309,8 +309,8 @@
   });
 
   test("asFuture with error accross setting stream", () async {
-    var completer = new StreamCompleter();
-    var controller = new StreamController();
+    var completer = StreamCompleter();
+    var controller = StreamController();
     var subscription =
         completer.stream.listen(unreachable("data"), cancelOnError: false);
     var done = subscription.asFuture();
@@ -327,7 +327,7 @@
 
   group("setError()", () {
     test("produces a stream that emits a single error", () {
-      var completer = new StreamCompleter();
+      var completer = StreamCompleter();
       completer.stream.listen(unreachable("data"),
           onError: expectAsync2((error, stackTrace) {
         expect(error, equals("oh no"));
@@ -338,7 +338,7 @@
 
     test("produces a stream that emits a single error on a later listen",
         () async {
-      var completer = new StreamCompleter();
+      var completer = StreamCompleter();
       completer.setError("oh no");
       await flushMicrotasks();
 
diff --git a/test/stream_group_test.dart b/test/stream_group_test.dart
index 83b685c..3c4a3a8 100644
--- a/test/stream_group_test.dart
+++ b/test/stream_group_test.dart
@@ -11,16 +11,16 @@
   group("single-subscription", () {
     StreamGroup<String> streamGroup;
     setUp(() {
-      streamGroup = new StreamGroup<String>();
+      streamGroup = StreamGroup<String>();
     });
 
     test("buffers events from multiple sources", () async {
-      var controller1 = new StreamController<String>();
+      var controller1 = StreamController<String>();
       streamGroup.add(controller1.stream);
       controller1.add("first");
       controller1.close();
 
-      var controller2 = new StreamController<String>();
+      var controller2 = StreamController<String>();
       streamGroup.add(controller2.stream);
       controller2.add("second");
       controller2.close();
@@ -34,12 +34,12 @@
     });
 
     test("buffers errors from multiple sources", () async {
-      var controller1 = new StreamController<String>();
+      var controller1 = StreamController<String>();
       streamGroup.add(controller1.stream);
       controller1.addError("first");
       controller1.close();
 
-      var controller2 = new StreamController<String>();
+      var controller2 = StreamController<String>();
       streamGroup.add(controller2.stream);
       controller2.addError("second");
       controller2.close();
@@ -49,14 +49,14 @@
       expect(streamGroup.close(), completes);
 
       var transformed = streamGroup.stream.transform(
-          new StreamTransformer<String, String>.fromHandlers(
+          StreamTransformer<String, String>.fromHandlers(
               handleError: (error, _, sink) => sink.add("error: $error")));
       expect(transformed.toList(),
           completion(equals(["error: first", "error: second"])));
     });
 
     test("buffers events and errors together", () async {
-      var controller = new StreamController<String>();
+      var controller = StreamController<String>();
       streamGroup.add(controller.stream);
 
       controller.add("first");
@@ -72,7 +72,7 @@
       expect(streamGroup.close(), completes);
 
       var transformed = streamGroup.stream.transform(
-          new StreamTransformer<String, String>.fromHandlers(
+          StreamTransformer<String, String>.fromHandlers(
               handleData: (data, sink) => sink.add("data: $data"),
               handleError: (error, _, sink) => sink.add("error: $error")));
       expect(
@@ -88,7 +88,7 @@
     });
 
     test("emits events once there's a listener", () {
-      var controller = new StreamController<String>();
+      var controller = StreamController<String>();
       streamGroup.add(controller.stream);
 
       expect(
@@ -102,7 +102,7 @@
     });
 
     test("doesn't buffer events from a broadcast stream", () async {
-      var controller = new StreamController<String>.broadcast();
+      var controller = StreamController<String>.broadcast();
       streamGroup.add(controller.stream);
 
       controller.add("first");
@@ -116,7 +116,7 @@
     });
 
     test("when paused, buffers events from a broadcast stream", () async {
-      var controller = new StreamController<String>.broadcast();
+      var controller = StreamController<String>.broadcast();
       streamGroup.add(controller.stream);
 
       var events = [];
@@ -136,7 +136,7 @@
     });
 
     test("emits events from a broadcast stream once there's a listener", () {
-      var controller = new StreamController<String>.broadcast();
+      var controller = StreamController<String>.broadcast();
       streamGroup.add(controller.stream);
 
       expect(
@@ -152,8 +152,7 @@
     test("forwards cancel errors", () async {
       var subscription = streamGroup.stream.listen(null);
 
-      var controller =
-          new StreamController<String>(onCancel: () => throw "error");
+      var controller = StreamController<String>(onCancel: () => throw "error");
       streamGroup.add(controller.stream);
       await flushMicrotasks();
 
@@ -163,9 +162,9 @@
     test("forwards a cancel future", () async {
       var subscription = streamGroup.stream.listen(null);
 
-      var completer = new Completer();
+      var completer = Completer();
       var controller =
-          new StreamController<String>(onCancel: () => completer.future);
+          StreamController<String>(onCancel: () => completer.future);
       streamGroup.add(controller.stream);
       await flushMicrotasks();
 
@@ -187,7 +186,7 @@
       await flushMicrotasks();
 
       var paused = false;
-      var controller = new StreamController<String>(
+      var controller = StreamController<String>(
           onPause: () => paused = true, onResume: () => paused = false);
 
       subscription.pause();
@@ -211,7 +210,7 @@
       test("immediately listens to and cancels the stream", () async {
         var listened = false;
         var canceled = false;
-        var controller = new StreamController<String>(onListen: () {
+        var controller = StreamController<String>(onListen: () {
           listened = true;
         }, onCancel: expectAsync0(() {
           expect(listened, isTrue);
@@ -226,15 +225,15 @@
 
       test("forwards cancel errors", () {
         var controller =
-            new StreamController<String>(onCancel: () => throw "error");
+            StreamController<String>(onCancel: () => throw "error");
 
         expect(streamGroup.add(controller.stream), throwsA("error"));
       });
 
       test("forwards a cancel future", () async {
-        var completer = new Completer();
+        var completer = Completer();
         var controller =
-            new StreamController<String>(onCancel: () => completer.future);
+            StreamController<String>(onCancel: () => completer.future);
 
         var fired = false;
         streamGroup.add(controller.stream).then((_) => fired = true);
@@ -252,16 +251,16 @@
   group("broadcast", () {
     StreamGroup<String> streamGroup;
     setUp(() {
-      streamGroup = new StreamGroup<String>.broadcast();
+      streamGroup = StreamGroup<String>.broadcast();
     });
 
     test("buffers events from multiple sources", () async {
-      var controller1 = new StreamController<String>();
+      var controller1 = StreamController<String>();
       streamGroup.add(controller1.stream);
       controller1.add("first");
       controller1.close();
 
-      var controller2 = new StreamController<String>();
+      var controller2 = StreamController<String>();
       streamGroup.add(controller2.stream);
       controller2.add("second");
       controller2.close();
@@ -275,10 +274,10 @@
     });
 
     test("emits events from multiple sources once there's a listener", () {
-      var controller1 = new StreamController<String>();
+      var controller1 = StreamController<String>();
       streamGroup.add(controller1.stream);
 
-      var controller2 = new StreamController<String>();
+      var controller2 = StreamController<String>();
       streamGroup.add(controller2.stream);
 
       expect(
@@ -294,7 +293,7 @@
 
     test("doesn't buffer events once a listener has been added and removed",
         () async {
-      var controller = new StreamController<String>();
+      var controller = StreamController<String>();
       streamGroup.add(controller.stream);
 
       streamGroup.stream.listen(null).cancel();
@@ -311,7 +310,7 @@
     });
 
     test("doesn't buffer events from a broadcast stream", () async {
-      var controller = new StreamController<String>.broadcast();
+      var controller = StreamController<String>.broadcast();
       streamGroup.add(controller.stream);
       controller.add("first");
       controller.addError("second");
@@ -324,7 +323,7 @@
     });
 
     test("emits events from a broadcast stream once there's a listener", () {
-      var controller = new StreamController<String>.broadcast();
+      var controller = StreamController<String>.broadcast();
       streamGroup.add(controller.stream);
 
       expect(
@@ -340,7 +339,7 @@
     test("cancels and re-listens broadcast streams", () async {
       var subscription = streamGroup.stream.listen(null);
 
-      var controller = new StreamController<String>.broadcast();
+      var controller = StreamController<String>.broadcast();
 
       streamGroup.add(controller.stream);
       await flushMicrotasks();
@@ -359,7 +358,7 @@
       var subscription = streamGroup.stream.listen(null);
 
       var controller =
-          new StreamController<String>(onCancel: expectAsync0(() {}, count: 0));
+          StreamController<String>(onCancel: expectAsync0(() {}, count: 0));
 
       streamGroup.add(controller.stream);
       await flushMicrotasks();
@@ -376,7 +375,7 @@
       var events = [];
       var subscription = streamGroup.stream.listen(events.add);
 
-      var controller = new StreamController<String>();
+      var controller = StreamController<String>();
       streamGroup.add(controller.stream);
       await flushMicrotasks();
 
@@ -396,7 +395,7 @@
     });
 
     test("a single-subscription stream can be removed while dormant", () async {
-      var controller = new StreamController<String>();
+      var controller = StreamController<String>();
       streamGroup.add(controller.stream);
       await flushMicrotasks();
 
@@ -415,17 +414,17 @@
 
   group("regardless of type", () {
     group("single-subscription", () {
-      regardlessOfType(() => new StreamGroup<String>());
+      regardlessOfType(() => StreamGroup<String>());
     });
 
     group("broadcast", () {
-      regardlessOfType(() => new StreamGroup<String>.broadcast());
+      regardlessOfType(() => StreamGroup<String>.broadcast());
     });
   });
 
   test("merge() emits events from all components streams", () {
-    var controller1 = new StreamController<String>();
-    var controller2 = new StreamController<String>();
+    var controller1 = StreamController<String>();
+    var controller2 = StreamController<String>();
 
     var merged = StreamGroup.merge([controller1.stream, controller2.stream]);
 
@@ -448,7 +447,7 @@
     group("while dormant", () {
       test("doesn't listen to the stream until the group is listened to",
           () async {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
 
         expect(streamGroup.add(controller.stream), isNull);
         await flushMicrotasks();
@@ -460,7 +459,7 @@
       });
 
       test("is a no-op if the stream is already in the group", () {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
         streamGroup.add(controller.stream);
         streamGroup.add(controller.stream);
         streamGroup.add(controller.stream);
@@ -478,7 +477,7 @@
       });
 
       test("listens to the stream immediately", () async {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
 
         expect(streamGroup.add(controller.stream), isNull);
         await flushMicrotasks();
@@ -486,7 +485,7 @@
       });
 
       test("is a no-op if the stream is already in the group", () async {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
 
         // If the stream were actually listened to more than once, future
         // calls to [add] would throw [StateError]s.
@@ -500,7 +499,7 @@
   group("remove()", () {
     group("while dormant", () {
       test("stops emitting events for a stream that's removed", () async {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
         streamGroup.add(controller.stream);
 
         expect(streamGroup.stream.toList(), completion(equals(["first"])));
@@ -514,14 +513,14 @@
       });
 
       test("is a no-op for an unknown stream", () {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
         expect(streamGroup.remove(controller.stream), isNull);
       });
 
       test("and closed closes the group when the last stream is removed",
           () async {
-        var controller1 = new StreamController<String>();
-        var controller2 = new StreamController<String>();
+        var controller1 = StreamController<String>();
+        var controller2 = StreamController<String>();
 
         streamGroup.add(controller1.stream);
         streamGroup.add(controller2.stream);
@@ -541,7 +540,7 @@
 
     group("while listening", () {
       test("doesn't emit events from a removed stream", () {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
         streamGroup.add(controller.stream);
 
         // The subscription to [controller.stream] is canceled synchronously, so
@@ -557,7 +556,7 @@
       });
 
       test("cancels the stream's subscription", () async {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
         streamGroup.add(controller.stream);
 
         streamGroup.stream.listen(null);
@@ -571,7 +570,7 @@
 
       test("forwards cancel errors", () async {
         var controller =
-            new StreamController<String>(onCancel: () => throw "error");
+            StreamController<String>(onCancel: () => throw "error");
         streamGroup.add(controller.stream);
 
         streamGroup.stream.listen(null);
@@ -581,9 +580,9 @@
       });
 
       test("forwards cancel futures", () async {
-        var completer = new Completer();
+        var completer = Completer();
         var controller =
-            new StreamController<String>(onCancel: () => completer.future);
+            StreamController<String>(onCancel: () => completer.future);
 
         streamGroup.stream.listen(null);
         await flushMicrotasks();
@@ -603,7 +602,7 @@
       });
 
       test("is a no-op for an unknown stream", () async {
-        var controller = new StreamController<String>();
+        var controller = StreamController<String>();
         streamGroup.stream.listen(null);
         await flushMicrotasks();
 
@@ -616,8 +615,8 @@
         streamGroup.stream.listen(null, onDone: () => done = true);
         await flushMicrotasks();
 
-        var controller1 = new StreamController<String>();
-        var controller2 = new StreamController<String>();
+        var controller1 = StreamController<String>();
+        var controller2 = StreamController<String>();
 
         streamGroup.add(controller1.stream);
         streamGroup.add(controller2.stream);
@@ -646,8 +645,8 @@
       test(
           "if there are streams, closes the group once those streams close "
           "and there's a listener", () async {
-        var controller1 = new StreamController<String>();
-        var controller2 = new StreamController<String>();
+        var controller1 = StreamController<String>();
+        var controller2 = StreamController<String>();
 
         streamGroup.add(controller1.stream);
         streamGroup.add(controller2.stream);
@@ -673,8 +672,8 @@
         streamGroup.stream.listen(null, onDone: () => done = true);
         await flushMicrotasks();
 
-        var controller1 = new StreamController<String>();
-        var controller2 = new StreamController<String>();
+        var controller1 = StreamController<String>();
+        var controller2 = StreamController<String>();
 
         streamGroup.add(controller1.stream);
         streamGroup.add(controller2.stream);
@@ -699,7 +698,7 @@
       var events = [];
       streamGroup.stream.listen(events.add);
 
-      var controller = new StreamController<String>();
+      var controller = StreamController<String>();
       streamGroup.add(controller.stream);
       await flushMicrotasks();
 
@@ -721,4 +720,4 @@
 }
 
 /// Wait for all microtasks to complete.
-Future flushMicrotasks() => new Future.delayed(Duration.zero);
+Future flushMicrotasks() => Future.delayed(Duration.zero);
diff --git a/test/stream_queue_test.dart b/test/stream_queue_test.dart
index 37dedb9..aaf1227 100644
--- a/test/stream_queue_test.dart
+++ b/test/stream_queue_test.dart
@@ -12,8 +12,8 @@
 main() {
   group("source stream", () {
     test("is listened to on first request, paused between requests", () async {
-      var controller = new StreamController<int>();
-      var events = new StreamQueue<int>(controller.stream);
+      var controller = StreamController<int>();
+      var events = StreamQueue<int>(controller.stream);
       await flushMicrotasks();
       expect(controller.hasListener, isFalse);
 
@@ -44,7 +44,7 @@
 
   group("eventsDispatched", () {
     test("increments after a next future completes", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
 
       expect(events.eventsDispatched, equals(0));
       await flushMicrotasks();
@@ -61,13 +61,13 @@
     });
 
     test("increments multiple times for multi-value requests", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       await events.take(3);
       expect(events.eventsDispatched, equals(3));
     });
 
     test("increments multiple times for an accepted transaction", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       await events.withTransaction((queue) async {
         await queue.next;
         await queue.next;
@@ -77,7 +77,7 @@
     });
 
     test("doesn't increment for rest requests", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       await events.rest.toList();
       expect(events.eventsDispatched, equals(0));
     });
@@ -85,7 +85,7 @@
 
   group("lookAhead operation", () {
     test("as simple list of events", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.lookAhead(4), [1, 2, 3, 4]);
       expect(await events.next, 1);
       expect(await events.lookAhead(2), [2, 3]);
@@ -95,7 +95,7 @@
     });
 
     test("of 0 events", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(events.lookAhead(0), completion([]));
       expect(events.next, completion(1));
       expect(events.lookAhead(0), completion([]));
@@ -111,7 +111,7 @@
     });
 
     test("with bad arguments throws", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(() => events.lookAhead(-1), throwsArgumentError);
       expect(await events.next, 1); // Did not consume event.
       expect(() => events.lookAhead(-1), throwsArgumentError);
@@ -120,13 +120,13 @@
     });
 
     test("of too many arguments", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.lookAhead(6), [1, 2, 3, 4]);
       await events.cancel();
     });
 
     test("too large later", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.lookAhead(6), [3, 4]);
@@ -134,7 +134,7 @@
     });
 
     test("error", () async {
-      var events = new StreamQueue<int>(createErrorStream());
+      var events = StreamQueue<int>(createErrorStream());
       expect(events.lookAhead(4), throwsA("To err is divine!"));
       expect(events.take(4), throwsA("To err is divine!"));
       expect(await events.next, 4);
@@ -144,7 +144,7 @@
 
   group("next operation", () {
     test("simple sequence of requests", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       for (int i = 1; i <= 4; i++) {
         expect(await events.next, i);
       }
@@ -152,7 +152,7 @@
     });
 
     test("multiple requests at the same time", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       var result = await Future.wait(
           [events.next, events.next, events.next, events.next]);
       expect(result, [1, 2, 3, 4]);
@@ -160,7 +160,7 @@
     });
 
     test("sequence of requests with error", () async {
-      var events = new StreamQueue<int>(createErrorStream());
+      var events = StreamQueue<int>(createErrorStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(events.next, throwsA("To err is divine!"));
@@ -171,7 +171,7 @@
 
   group("skip operation", () {
     test("of two elements in the middle of sequence", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.skip(2), 0);
       expect(await events.next, 4);
@@ -179,7 +179,7 @@
     });
 
     test("with negative/bad arguments throws", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(() => events.skip(-1), throwsArgumentError);
       // A non-int throws either a type error or an argument error,
       // depending on whether it's checked mode or not.
@@ -190,7 +190,7 @@
     });
 
     test("of 0 elements works", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(events.skip(0), completion(0));
       expect(events.next, completion(1));
       expect(events.skip(0), completion(0));
@@ -206,13 +206,13 @@
     });
 
     test("of too many events ends at stream start", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.skip(6), 2);
       await events.cancel();
     });
 
     test("of too many events after some events", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.skip(6), 4);
@@ -220,7 +220,7 @@
     });
 
     test("of too many events ends at stream end", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.next, 3);
@@ -230,20 +230,20 @@
     });
 
     test("of events with error", () async {
-      var events = new StreamQueue<int>(createErrorStream());
+      var events = StreamQueue<int>(createErrorStream());
       expect(events.skip(4), throwsA("To err is divine!"));
       expect(await events.next, 4);
       await events.cancel();
     });
 
     test("of events with error, and skip again after", () async {
-      var events = new StreamQueue<int>(createErrorStream());
+      var events = StreamQueue<int>(createErrorStream());
       expect(events.skip(4), throwsA("To err is divine!"));
       expect(events.skip(2), completion(1));
       await events.cancel();
     });
     test("multiple skips at same time complete in order.", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       var skip1 = events.skip(1);
       var skip2 = events.skip(0);
       var skip3 = events.skip(4);
@@ -267,7 +267,7 @@
 
   group("take operation", () {
     test("as simple take of events", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.take(2), [2, 3]);
       expect(await events.next, 4);
@@ -275,7 +275,7 @@
     });
 
     test("of 0 events", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(events.take(0), completion([]));
       expect(events.next, completion(1));
       expect(events.take(0), completion([]));
@@ -291,7 +291,7 @@
     });
 
     test("with bad arguments throws", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(() => events.take(-1), throwsArgumentError);
       expect(await events.next, 1); // Did not consume event.
       expect(() => events.take(-1), throwsArgumentError);
@@ -300,13 +300,13 @@
     });
 
     test("of too many arguments", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.take(6), [1, 2, 3, 4]);
       await events.cancel();
     });
 
     test("too large later", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.take(6), [3, 4]);
@@ -314,7 +314,7 @@
     });
 
     test("error", () async {
-      var events = new StreamQueue<int>(createErrorStream());
+      var events = StreamQueue<int>(createErrorStream());
       expect(events.take(4), throwsA("To err is divine!"));
       expect(await events.next, 4);
       await events.cancel();
@@ -323,18 +323,18 @@
 
   group("rest operation", () {
     test("after single next", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.rest.toList(), [2, 3, 4]);
     });
 
     test("at start", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.rest.toList(), [1, 2, 3, 4]);
     });
 
     test("at end", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.next, 3);
@@ -343,7 +343,7 @@
     });
 
     test("after end", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.next, 3);
@@ -353,7 +353,7 @@
     });
 
     test("after receiving done requested before", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       var next1 = events.next;
       var next2 = events.next;
       var next3 = events.next;
@@ -368,17 +368,17 @@
     });
 
     test("with an error event error", () async {
-      var events = new StreamQueue<int>(createErrorStream());
+      var events = StreamQueue<int>(createErrorStream());
       expect(await events.next, 1);
       var rest = events.rest;
-      var events2 = new StreamQueue(rest);
+      var events2 = StreamQueue(rest);
       expect(await events2.next, 2);
       expect(events2.next, throwsA("To err is divine!"));
       expect(await events2.next, 4);
     });
 
     test("closes the events, prevents other operations", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       var stream = events.rest;
       expect(() => events.next, throwsStateError);
       expect(() => events.skip(1), throwsStateError);
@@ -389,9 +389,9 @@
     });
 
     test("forwards to underlying stream", () async {
-      var cancel = new Completer();
-      var controller = new StreamController<int>(onCancel: () => cancel.future);
-      var events = new StreamQueue<int>(controller.stream);
+      var cancel = Completer();
+      var controller = StreamController<int>(onCancel: () => cancel.future);
+      var events = StreamQueue<int>(controller.stream);
       expect(controller.hasListener, isFalse);
       var next = events.next;
       expect(controller.hasListener, isTrue);
@@ -437,7 +437,7 @@
 
   group("peek operation", () {
     test("peeks one event", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.peek, 1);
       expect(await events.next, 1);
       expect(await events.peek, 2);
@@ -449,14 +449,14 @@
       await events.cancel();
     });
     test("multiple requests at the same time", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       var result = await Future.wait(
           [events.peek, events.peek, events.next, events.peek, events.peek]);
       expect(result, [1, 1, 1, 2, 2]);
       await events.cancel();
     });
     test("sequence of requests with error", () async {
-      var events = new StreamQueue<int>(createErrorStream());
+      var events = StreamQueue<int>(createErrorStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(events.peek, throwsA("To err is divine!"));
@@ -470,7 +470,7 @@
 
   group("cancel operation", () {
     test("closes the events, prevents any other operation", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       await events.cancel();
       expect(() => events.lookAhead(1), throwsStateError);
       expect(() => events.next, throwsStateError);
@@ -483,16 +483,16 @@
 
     test("cancels underlying subscription when called before any event",
         () async {
-      var cancelFuture = new Future.value(42);
-      var controller = new StreamController<int>(onCancel: () => cancelFuture);
-      var events = new StreamQueue<int>(controller.stream);
+      var cancelFuture = Future.value(42);
+      var controller = StreamController<int>(onCancel: () => cancelFuture);
+      var events = StreamQueue<int>(controller.stream);
       expect(await events.cancel(), 42);
     });
 
     test("cancels underlying subscription, returns result", () async {
-      var cancelFuture = new Future.value(42);
-      var controller = new StreamController<int>(onCancel: () => cancelFuture);
-      var events = new StreamQueue<int>(controller.stream);
+      var cancelFuture = Future.value(42);
+      var controller = StreamController<int>(onCancel: () => cancelFuture);
+      var events = StreamQueue<int>(controller.stream);
       controller.add(1);
       expect(await events.next, 1);
       expect(await events.cancel(), 42);
@@ -500,7 +500,7 @@
 
     group("with immediate: true", () {
       test("closes the events, prevents any other operation", () async {
-        var events = new StreamQueue<int>(createStream());
+        var events = StreamQueue<int>(createStream());
         await events.cancel(immediate: true);
         expect(() => events.next, throwsStateError);
         expect(() => events.skip(1), throwsStateError);
@@ -510,10 +510,10 @@
       });
 
       test("cancels the underlying subscription immediately", () async {
-        var controller = new StreamController<int>();
+        var controller = StreamController<int>();
         controller.add(1);
 
-        var events = new StreamQueue<int>(controller.stream);
+        var events = StreamQueue<int>(controller.stream);
         expect(await events.next, 1);
         expect(controller.hasListener, isTrue);
 
@@ -523,16 +523,15 @@
 
       test("cancels the underlying subscription when called before any event",
           () async {
-        var cancelFuture = new Future.value(42);
-        var controller =
-            new StreamController<int>(onCancel: () => cancelFuture);
+        var cancelFuture = Future.value(42);
+        var controller = StreamController<int>(onCancel: () => cancelFuture);
 
-        var events = new StreamQueue<int>(controller.stream);
+        var events = StreamQueue<int>(controller.stream);
         expect(await events.cancel(immediate: true), 42);
       });
 
       test("closes pending requests", () async {
-        var events = new StreamQueue<int>(createStream());
+        var events = StreamQueue<int>(createStream());
         expect(await events.next, 1);
         expect(events.next, throwsStateError);
         expect(events.hasNext, completion(isFalse));
@@ -543,8 +542,8 @@
       test("returns the result of closing the underlying subscription",
           () async {
         var controller =
-            new StreamController<int>(onCancel: () => new Future.value(42));
-        var events = new StreamQueue<int>(controller.stream);
+            StreamController<int>(onCancel: () => Future.value(42));
+        var events = StreamQueue<int>(controller.stream);
         expect(await events.cancel(immediate: true), 42);
       });
 
@@ -552,8 +551,8 @@
           () async {
         var wasListened = false;
         var controller =
-            new StreamController<int>(onListen: () => wasListened = true);
-        var events = new StreamQueue<int>(controller.stream);
+            StreamController<int>(onListen: () => wasListened = true);
+        var events = StreamQueue<int>(controller.stream);
         expect(wasListened, isFalse);
         expect(controller.hasListener, isFalse);
 
@@ -566,18 +565,18 @@
 
   group("hasNext operation", () {
     test("true at start", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.hasNext, isTrue);
     });
 
     test("true after start", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, isTrue);
     });
 
     test("true at end", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       for (int i = 1; i <= 4; i++) {
         expect(await events.next, i);
       }
@@ -585,7 +584,7 @@
     });
 
     test("true when enqueued", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       var values = <int>[];
       for (int i = 1; i <= 3; i++) {
         events.next.then(values.add);
@@ -596,7 +595,7 @@
     });
 
     test("false when enqueued", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       var values = <int>[];
       for (int i = 1; i <= 4; i++) {
         events.next.then(values.add);
@@ -607,8 +606,8 @@
     });
 
     test("true when data event", () async {
-      var controller = new StreamController<int>();
-      var events = new StreamQueue<int>(controller.stream);
+      var controller = StreamController<int>();
+      var events = StreamQueue<int>(controller.stream);
 
       bool hasNext;
       events.hasNext.then((result) {
@@ -623,8 +622,8 @@
     });
 
     test("true when error event", () async {
-      var controller = new StreamController<int>();
-      var events = new StreamQueue<int>(controller.stream);
+      var controller = StreamController<int>();
+      var events = StreamQueue<int>(controller.stream);
 
       bool hasNext;
       events.hasNext.then((result) {
@@ -640,7 +639,7 @@
     });
 
     test("- hasNext after hasNext", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.hasNext, true);
       expect(await events.hasNext, true);
       expect(await events.next, 1);
@@ -658,7 +657,7 @@
     });
 
     test("- next after true", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       expect(await events.next, 2);
@@ -666,7 +665,7 @@
     });
 
     test("- next after true, enqueued", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       var responses = <Object>[];
       events.next.then(responses.add);
       events.hasNext.then(responses.add);
@@ -678,7 +677,7 @@
     });
 
     test("- skip 0 after true", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       expect(await events.skip(0), 0);
@@ -686,7 +685,7 @@
     });
 
     test("- skip 1 after true", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       expect(await events.skip(1), 0);
@@ -694,7 +693,7 @@
     });
 
     test("- skip 2 after true", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       expect(await events.skip(2), 0);
@@ -702,7 +701,7 @@
     });
 
     test("- take 0 after true", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       expect(await events.take(0), isEmpty);
@@ -710,7 +709,7 @@
     });
 
     test("- take 1 after true", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       expect(await events.take(1), [2]);
@@ -718,7 +717,7 @@
     });
 
     test("- take 2 after true", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       expect(await events.take(2), [2, 3]);
@@ -726,7 +725,7 @@
     });
 
     test("- rest after true", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       var stream = events.rest;
@@ -734,7 +733,7 @@
     });
 
     test("- rest after true, at last", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.next, 3);
@@ -744,7 +743,7 @@
     });
 
     test("- rest after false", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.next, 3);
@@ -755,7 +754,7 @@
     });
 
     test("- cancel after true on data", () async {
-      var events = new StreamQueue<int>(createStream());
+      var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.hasNext, true);
@@ -763,7 +762,7 @@
     });
 
     test("- cancel after true on error", () async {
-      var events = new StreamQueue<int>(createErrorStream());
+      var events = StreamQueue<int>(createErrorStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
       expect(await events.hasNext, true);
@@ -777,7 +776,7 @@
     StreamQueue<int> queue1;
     StreamQueue<int> queue2;
     setUp(() async {
-      events = new StreamQueue(createStream());
+      events = StreamQueue(createStream());
       expect(await events.next, 1);
       transaction = events.startTransaction();
       queue1 = transaction.newQueue();
@@ -808,7 +807,7 @@
       });
 
       test("independently emit errors", () async {
-        events = new StreamQueue(createErrorStream());
+        events = StreamQueue(createErrorStream());
         expect(await events.next, 1);
         transaction = events.startTransaction();
         queue1 = transaction.newQueue();
@@ -872,8 +871,8 @@
 
       // Regression test.
       test("pending child rest requests emit no more events", () async {
-        var controller = new StreamController();
-        var events = new StreamQueue(controller.stream);
+        var controller = StreamController();
+        var events = StreamQueue(controller.stream);
         var transaction = events.startTransaction();
         var queue = transaction.newQueue();
 
@@ -906,8 +905,8 @@
       });
 
       test("before the transaction emits any events, does nothing", () async {
-        var controller = new StreamController();
-        var events = new StreamQueue(controller.stream);
+        var controller = StreamController();
+        var events = StreamQueue(controller.stream);
 
         // Queue a request before the transaction, but don't let it complete
         // until we're done with the transaction.
@@ -983,8 +982,8 @@
       });
 
       test("before the transaction emits any events, does nothing", () async {
-        var controller = new StreamController();
-        var events = new StreamQueue(controller.stream);
+        var controller = StreamController();
+        var events = StreamQueue(controller.stream);
 
         // Queue a request before the transaction, but don't let it complete
         // until we're done with the transaction.
@@ -1006,7 +1005,7 @@
   group("withTransaction operation", () {
     StreamQueue<int> events;
     setUp(() async {
-      events = new StreamQueue(createStream());
+      events = StreamQueue(createStream());
       expect(await events.next, 1);
     });
 
@@ -1060,7 +1059,7 @@
   group("cancelable operation", () {
     StreamQueue<int> events;
     setUp(() async {
-      events = new StreamQueue(createStream());
+      events = StreamQueue(createStream());
       expect(await events.next, 1);
     });
 
@@ -1120,7 +1119,7 @@
     // doing rest. Each of the first rounds do 10 events of each type,
     // the rest does 20 elements.
     var eventCount = 20 * (3 * 3 + 1);
-    var events = new StreamQueue<int>(createLongStream(eventCount));
+    var events = StreamQueue<int>(createLongStream(eventCount));
 
     // Test expecting [startIndex .. startIndex + 9] as events using
     // `next`.
@@ -1139,7 +1138,7 @@
     // `take(10)`.
     takeTest(startIndex) {
       expect(events.take(10),
-          completion(new List.generate(10, (i) => startIndex + i)));
+          completion(List.generate(10, (i) => startIndex + i)));
     }
 
     var tests = [nextTest, skipTest, takeTest];
@@ -1155,11 +1154,11 @@
     }
     // Then expect 20 more events as a `rest` call.
     expect(events.rest.toList(),
-        completion(new List.generate(20, (i) => counter + i)));
+        completion(List.generate(20, (i) => counter + i)));
   });
 }
 
-typedef T Func1Required<T>(T value);
+typedef Func1Required<T> = T Function(T value);
 
 Stream<int> createStream() async* {
   yield 1;
@@ -1172,7 +1171,7 @@
 }
 
 Stream<int> createErrorStream() {
-  var controller = new StreamController<int>();
+  var controller = StreamController<int>();
   () async {
     controller.add(1);
     await flushMicrotasks();
diff --git a/test/stream_sink_completer_test.dart b/test/stream_sink_completer_test.dart
index a149a7f..56860ce 100644
--- a/test/stream_sink_completer_test.dart
+++ b/test/stream_sink_completer_test.dart
@@ -12,12 +12,12 @@
 main() {
   StreamSinkCompleter completer;
   setUp(() {
-    completer = new StreamSinkCompleter();
+    completer = StreamSinkCompleter();
   });
 
   group("when a stream is linked before events are added", () {
     test("data events are forwarded", () {
-      var sink = new TestSink();
+      var sink = TestSink();
       completer.setDestinationSink(sink);
       completer.sink..add(1)..add(2)..add(3)..add(4);
 
@@ -28,7 +28,7 @@
     });
 
     test("error events are forwarded", () {
-      var sink = new TestSink();
+      var sink = TestSink();
       completer.setDestinationSink(sink);
       completer.sink..addError("oh no")..addError("that's bad");
 
@@ -37,10 +37,10 @@
     });
 
     test("addStream is forwarded", () async {
-      var sink = new TestSink();
+      var sink = TestSink();
       completer.setDestinationSink(sink);
 
-      var controller = new StreamController();
+      var controller = StreamController();
       completer.sink.addStream(controller.stream);
 
       controller.add(1);
@@ -61,15 +61,15 @@
     });
 
     test("close() is forwarded", () {
-      var sink = new TestSink();
+      var sink = TestSink();
       completer.setDestinationSink(sink);
       completer.sink.close();
       expect(sink.isClosed, isTrue);
     });
 
     test("the future from the inner close() is returned", () async {
-      var closeCompleter = new Completer();
-      var sink = new TestSink(onDone: () => closeCompleter.future);
+      var closeCompleter = Completer();
+      var sink = TestSink(onDone: () => closeCompleter.future);
       completer.setDestinationSink(sink);
 
       var closeCompleted = false;
@@ -86,14 +86,14 @@
     });
 
     test("errors are forwarded from the inner close()", () {
-      var sink = new TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw "oh no");
       completer.setDestinationSink(sink);
       expect(completer.sink.done, throwsA("oh no"));
       expect(completer.sink.close(), throwsA("oh no"));
     });
 
     test("errors aren't top-leveled if only close() is listened to", () async {
-      var sink = new TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw "oh no");
       completer.setDestinationSink(sink);
       expect(completer.sink.close(), throwsA("oh no"));
 
@@ -102,7 +102,7 @@
     });
 
     test("errors aren't top-leveled if only done is listened to", () async {
-      var sink = new TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw "oh no");
       completer.setDestinationSink(sink);
       completer.sink.close();
       expect(completer.sink.done, throwsA("oh no"));
@@ -117,7 +117,7 @@
       completer.sink..add(1)..add(2)..add(3)..add(4);
       await flushMicrotasks();
 
-      var sink = new TestSink();
+      var sink = TestSink();
       completer.setDestinationSink(sink);
       await flushMicrotasks();
 
@@ -131,7 +131,7 @@
       completer.sink..addError("oh no")..addError("that's bad");
       await flushMicrotasks();
 
-      var sink = new TestSink();
+      var sink = TestSink();
       completer.setDestinationSink(sink);
       await flushMicrotasks();
 
@@ -140,7 +140,7 @@
     });
 
     test("addStream is forwarded", () async {
-      var controller = new StreamController();
+      var controller = StreamController();
       completer.sink.addStream(controller.stream);
 
       controller.add(1);
@@ -150,7 +150,7 @@
       controller.close();
       await flushMicrotasks();
 
-      var sink = new TestSink();
+      var sink = TestSink();
       completer.setDestinationSink(sink);
       await flushMicrotasks();
 
@@ -165,7 +165,7 @@
       completer.sink.close();
       await flushMicrotasks();
 
-      var sink = new TestSink();
+      var sink = TestSink();
       completer.setDestinationSink(sink);
       await flushMicrotasks();
 
@@ -179,8 +179,8 @@
       }));
       await flushMicrotasks();
 
-      var closeCompleter = new Completer();
-      var sink = new TestSink(onDone: () => closeCompleter.future);
+      var closeCompleter = Completer();
+      var sink = TestSink(onDone: () => closeCompleter.future);
       completer.setDestinationSink(sink);
       await flushMicrotasks();
       expect(closeCompleted, isFalse);
@@ -195,7 +195,7 @@
       expect(completer.sink.close(), throwsA("oh no"));
       await flushMicrotasks();
 
-      var sink = new TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw "oh no");
       completer.setDestinationSink(sink);
     });
 
@@ -203,7 +203,7 @@
       expect(completer.sink.close(), throwsA("oh no"));
       await flushMicrotasks();
 
-      var sink = new TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw "oh no");
       completer.setDestinationSink(sink);
 
       // Give the event loop a chance to top-level errors if it's going to.
@@ -215,7 +215,7 @@
       expect(completer.sink.done, throwsA("oh no"));
       await flushMicrotasks();
 
-      var sink = new TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw "oh no");
       completer.setDestinationSink(sink);
 
       // Give the event loop a chance to top-level errors if it's going to.
@@ -228,7 +228,7 @@
     expect(completer.sink.close(), completes);
     await flushMicrotasks();
 
-    completer.setDestinationSink(new TestSink());
+    completer.setDestinationSink(TestSink());
     await flushMicrotasks();
 
     expect(completer.sink.done, completes);
@@ -239,7 +239,7 @@
     expect(completer.sink.done, completes);
     await flushMicrotasks();
 
-    completer.setDestinationSink(new TestSink());
+    completer.setDestinationSink(TestSink());
     await flushMicrotasks();
 
     expect(completer.sink.close(), completes);
@@ -247,14 +247,14 @@
 
   group("fromFuture()", () {
     test("with a successful completion", () async {
-      var futureCompleter = new Completer<StreamSink>();
+      var futureCompleter = Completer<StreamSink>();
       var sink = StreamSinkCompleter.fromFuture(futureCompleter.future);
       sink.add(1);
       sink.add(2);
       sink.add(3);
       sink.close();
 
-      var testSink = new TestSink();
+      var testSink = TestSink();
       futureCompleter.complete(testSink);
       await testSink.done;
 
@@ -264,7 +264,7 @@
     });
 
     test("with an error", () async {
-      var futureCompleter = new Completer<StreamSink>();
+      var futureCompleter = Completer<StreamSink>();
       var sink = StreamSinkCompleter.fromFuture(futureCompleter.future);
       expect(sink.done, throwsA("oh no"));
       futureCompleter.completeError("oh no");
@@ -288,10 +288,8 @@
   });
 
   test("doesn't allow the destination sink to be set multiple times", () {
-    completer.setDestinationSink(new TestSink());
-    expect(
-        () => completer.setDestinationSink(new TestSink()), throwsStateError);
-    expect(
-        () => completer.setDestinationSink(new TestSink()), throwsStateError);
+    completer.setDestinationSink(TestSink());
+    expect(() => completer.setDestinationSink(TestSink()), throwsStateError);
+    expect(() => completer.setDestinationSink(TestSink()), throwsStateError);
   });
 }
diff --git a/test/stream_sink_transformer_test.dart b/test/stream_sink_transformer_test.dart
index 552bdaa..5e981a6 100644
--- a/test/stream_sink_transformer_test.dart
+++ b/test/stream_sink_transformer_test.dart
@@ -12,13 +12,13 @@
 void main() {
   StreamController controller;
   setUp(() {
-    controller = new StreamController();
+    controller = StreamController();
   });
 
   group("fromStreamTransformer", () {
     test("transforms data events", () {
-      var transformer = new StreamSinkTransformer.fromStreamTransformer(
-          new StreamTransformer.fromHandlers(handleData: (i, sink) {
+      var transformer = StreamSinkTransformer.fromStreamTransformer(
+          StreamTransformer.fromHandlers(handleData: (i, sink) {
         sink.add(i * 2);
       }));
       var sink = transformer.bind(controller.sink);
@@ -35,9 +35,8 @@
     });
 
     test("transforms error events", () {
-      var transformer = new StreamSinkTransformer.fromStreamTransformer(
-          new StreamTransformer.fromHandlers(
-              handleError: (i, stackTrace, sink) {
+      var transformer = StreamSinkTransformer.fromStreamTransformer(
+          StreamTransformer.fromHandlers(handleError: (i, stackTrace, sink) {
         sink.addError((i as num) * 2, stackTrace);
       }));
       var sink = transformer.bind(controller.sink);
@@ -57,8 +56,8 @@
     });
 
     test("transforms done events", () {
-      var transformer = new StreamSinkTransformer.fromStreamTransformer(
-          new StreamTransformer.fromHandlers(handleDone: (sink) {
+      var transformer = StreamSinkTransformer.fromStreamTransformer(
+          StreamTransformer.fromHandlers(handleDone: (sink) {
         sink.add(1);
         sink.close();
       }));
@@ -73,16 +72,16 @@
     });
 
     test("forwards the future from inner.close", () async {
-      var transformer = new StreamSinkTransformer.fromStreamTransformer(
-          new StreamTransformer.fromHandlers());
-      var innerSink = new CompleterStreamSink();
+      var transformer = StreamSinkTransformer.fromStreamTransformer(
+          StreamTransformer.fromHandlers());
+      var innerSink = CompleterStreamSink();
       var sink = transformer.bind(innerSink);
 
       // The futures shouldn't complete until the inner sink's close future
       // completes.
-      var doneResult = new ResultFuture(sink.done);
+      var doneResult = ResultFuture(sink.done);
       doneResult.catchError((_) {});
-      var closeResult = new ResultFuture(sink.close());
+      var closeResult = ResultFuture(sink.close());
       closeResult.catchError((_) {});
       await flushMicrotasks();
       expect(doneResult.isComplete, isFalse);
@@ -96,11 +95,11 @@
     });
 
     test("doesn't top-level the future from inner.close", () async {
-      var transformer = new StreamSinkTransformer.fromStreamTransformer(
-          new StreamTransformer.fromHandlers(handleData: (_, sink) {
+      var transformer = StreamSinkTransformer.fromStreamTransformer(
+          StreamTransformer.fromHandlers(handleData: (_, sink) {
         sink.close();
       }));
-      var innerSink = new CompleterStreamSink();
+      var innerSink = CompleterStreamSink();
       var sink = transformer.bind(innerSink);
 
       // This will close the inner sink, but it shouldn't top-level the error.
@@ -118,7 +117,7 @@
   group("fromHandlers", () {
     test("transforms data events", () {
       var transformer =
-          new StreamSinkTransformer.fromHandlers(handleData: (i, sink) {
+          StreamSinkTransformer.fromHandlers(handleData: (i, sink) {
         sink.add(i * 2);
       });
       var sink = transformer.bind(controller.sink);
@@ -135,7 +134,7 @@
     });
 
     test("transforms error events", () {
-      var transformer = new StreamSinkTransformer.fromHandlers(
+      var transformer = StreamSinkTransformer.fromHandlers(
           handleError: (i, stackTrace, sink) {
         sink.addError((i as num) * 2, stackTrace);
       });
@@ -156,8 +155,7 @@
     });
 
     test("transforms done events", () {
-      var transformer =
-          new StreamSinkTransformer.fromHandlers(handleDone: (sink) {
+      var transformer = StreamSinkTransformer.fromHandlers(handleDone: (sink) {
         sink.add(1);
         sink.close();
       });
@@ -172,15 +170,15 @@
     });
 
     test("forwards the future from inner.close", () async {
-      var transformer = new StreamSinkTransformer.fromHandlers();
-      var innerSink = new CompleterStreamSink();
+      var transformer = StreamSinkTransformer.fromHandlers();
+      var innerSink = CompleterStreamSink();
       var sink = transformer.bind(innerSink);
 
       // The futures shouldn't complete until the inner sink's close future
       // completes.
-      var doneResult = new ResultFuture(sink.done);
+      var doneResult = ResultFuture(sink.done);
       doneResult.catchError((_) {});
-      var closeResult = new ResultFuture(sink.close());
+      var closeResult = ResultFuture(sink.close());
       closeResult.catchError((_) {});
       await flushMicrotasks();
       expect(doneResult.isComplete, isFalse);
@@ -195,10 +193,10 @@
 
     test("doesn't top-level the future from inner.close", () async {
       var transformer =
-          new StreamSinkTransformer.fromHandlers(handleData: (_, sink) {
+          StreamSinkTransformer.fromHandlers(handleData: (_, sink) {
         sink.close();
       });
-      var innerSink = new CompleterStreamSink();
+      var innerSink = CompleterStreamSink();
       var sink = transformer.bind(innerSink);
 
       // This will close the inner sink, but it shouldn't top-level the error.
diff --git a/test/stream_splitter_test.dart b/test/stream_splitter_test.dart
index c118b12..497f125 100644
--- a/test/stream_splitter_test.dart
+++ b/test/stream_splitter_test.dart
@@ -11,8 +11,8 @@
   StreamController<int> controller;
   StreamSplitter splitter;
   setUp(() {
-    controller = new StreamController<int>();
-    splitter = new StreamSplitter<int>(controller.stream);
+    controller = StreamController<int>();
+    splitter = StreamSplitter<int>(controller.stream);
   });
 
   test("a branch that's created before the stream starts to replay it",
@@ -289,4 +289,4 @@
 }
 
 /// Wait for all microtasks to complete.
-Future flushMicrotasks() => new Future.delayed(Duration.zero);
+Future flushMicrotasks() => Future.delayed(Duration.zero);
diff --git a/test/stream_zip_test.dart b/test/stream_zip_test.dart
index 018c8ab..1e5f524 100644
--- a/test/stream_zip_test.dart
+++ b/test/stream_zip_test.dart
@@ -17,10 +17,10 @@
 /// at periodic intervals.
 Stream mks(Iterable iterable) {
   Iterator iterator = iterable.iterator;
-  StreamController controller = new StreamController();
+  StreamController controller = StreamController();
   // Some varying time between 3 and 10 ms.
   int ms = ((++ctr) * 5) % 7 + 3;
-  new Timer.periodic(new Duration(milliseconds: ms), (Timer timer) {
+  Timer.periodic(Duration(milliseconds: ms), (Timer timer) {
     if (iterator.moveNext()) {
       controller.add(iterator.current);
     } else {
@@ -38,7 +38,7 @@
   // Test that zipping [streams] gives the results iterated by [expectedData].
   testZip(Iterable<Stream> streams, Iterable expectedData) {
     List data = [];
-    Stream zip = new StreamZip(streams);
+    Stream zip = StreamZip(streams);
     zip.listen(data.add, onDone: expectAsync0(() {
       expect(data, equals(expectedData));
     }));
@@ -145,9 +145,8 @@
   test("Other-streams", () {
     Stream st1 = mks([1, 2, 3, 4, 5, 6]).where((x) => x < 4);
     Stream st2 =
-        new Stream.periodic(const Duration(milliseconds: 5), (x) => x + 4)
-            .take(3);
-    StreamController c = new StreamController.broadcast();
+        Stream.periodic(const Duration(milliseconds: 5), (x) => x + 4).take(3);
+    StreamController c = StreamController.broadcast();
     Stream st3 = c.stream;
     testZip([
       st1,
@@ -167,7 +166,7 @@
 
   test("Error 1", () {
     expect(
-        new StreamZip([
+        StreamZip([
           streamError(mks([1, 2, 3]), 2, "BAD-1"),
           mks([4, 5, 6]),
           mks([7, 8, 9])
@@ -177,7 +176,7 @@
 
   test("Error 2", () {
     expect(
-        new StreamZip([
+        StreamZip([
           mks([1, 2, 3]),
           streamError(mks([4, 5, 6]), 5, "BAD-2"),
           mks([7, 8, 9])
@@ -187,7 +186,7 @@
 
   test("Error 3", () {
     expect(
-        new StreamZip([
+        StreamZip([
           mks([1, 2, 3]),
           mks([4, 5, 6]),
           streamError(mks([7, 8, 9]), 8, "BAD-3")
@@ -197,7 +196,7 @@
 
   test("Error at end", () {
     expect(
-        new StreamZip([
+        StreamZip([
           mks([1, 2, 3]),
           streamError(mks([4, 5, 6]), 6, "BAD-4"),
           mks([7, 8, 9])
@@ -209,21 +208,21 @@
     // StreamControllers' streams with no "close" called will never be done,
     // so the fourth event of the first stream is guaranteed to come first.
     expect(
-        new StreamZip([
+        StreamZip([
           streamError(mks([1, 2, 3, 4]), 4, "BAD-5"),
-          (new StreamController()..add(4)..add(5)..add(6)).stream,
-          (new StreamController()..add(7)..add(8)..add(9)).stream
+          (StreamController()..add(4)..add(5)..add(6)).stream,
+          (StreamController()..add(7)..add(8)..add(9)).stream
         ]).toList(),
         throwsA(equals("BAD-5")));
   });
 
   test("Error after first end", () {
-    StreamController controller = new StreamController();
+    StreamController controller = StreamController();
     controller..add(7)..add(8)..add(9);
     // Transformer that puts error into controller when one of the first two
     // streams have sent a done event.
     StreamTransformer trans =
-        new StreamTransformer.fromHandlers(handleDone: (EventSink s) {
+        StreamTransformer.fromHandlers(handleDone: (EventSink s) {
       Timer.run(() {
         controller.addError("BAD-6");
       });
@@ -242,14 +241,14 @@
 
   test("Pause/Resume", () {
     int sc1p = 0;
-    StreamController c1 = new StreamController(onPause: () {
+    StreamController c1 = StreamController(onPause: () {
       sc1p++;
     }, onResume: () {
       sc1p--;
     });
 
     int sc2p = 0;
-    StreamController c2 = new StreamController(onPause: () {
+    StreamController c2 = StreamController(onPause: () {
       sc2p++;
     }, onResume: () {
       sc2p--;
@@ -260,12 +259,12 @@
       expect(sc2p, equals(0));
     }); // Call to complete test.
 
-    Stream zip = new StreamZip([c1.stream, c2.stream]);
+    Stream zip = StreamZip([c1.stream, c2.stream]);
 
-    const ms25 = const Duration(milliseconds: 25);
+    const ms25 = Duration(milliseconds: 25);
 
     // StreamIterator uses pause and resume to control flow.
-    StreamIterator it = new StreamIterator(zip);
+    StreamIterator it = StreamIterator(zip);
 
     it.moveNext().then((hasMore) {
       expect(hasMore, isTrue);
@@ -279,7 +278,7 @@
     }).then((hasMore) {
       expect(hasMore, isTrue);
       expect(it.current, equals([5, 6]));
-      new Future.delayed(ms25).then((_) {
+      Future.delayed(ms25).then((_) {
         c2.add(8);
       });
       return it.moveNext();
@@ -303,18 +302,18 @@
   });
 
   test("pause-resume2", () {
-    var s1 = new Stream.fromIterable([0, 2, 4, 6, 8]);
-    var s2 = new Stream.fromIterable([1, 3, 5, 7]);
-    var sz = new StreamZip([s1, s2]);
+    var s1 = Stream.fromIterable([0, 2, 4, 6, 8]);
+    var s2 = Stream.fromIterable([1, 3, 5, 7]);
+    var sz = StreamZip([s1, s2]);
     int ctr = 0;
     StreamSubscription sub;
     sub = sz.listen(expectAsync1((v) {
       expect(v, equals([ctr * 2, ctr * 2 + 1]));
       if (ctr == 1) {
-        sub.pause(new Future.delayed(const Duration(milliseconds: 25)));
+        sub.pause(Future.delayed(const Duration(milliseconds: 25)));
       } else if (ctr == 2) {
         sub.pause();
-        new Future.delayed(const Duration(milliseconds: 25)).then((_) {
+        Future.delayed(const Duration(milliseconds: 25)).then((_) {
           sub.resume();
         });
       }
diff --git a/test/stream_zip_zone_test.dart b/test/stream_zip_zone_test.dart
index a0773a6..c7756e6 100644
--- a/test/stream_zip_zone_test.dart
+++ b/test/stream_zip_zone_test.dart
@@ -10,19 +10,19 @@
 
 main() {
   StreamController controller;
-  controller = new StreamController();
+  controller = StreamController();
   testStream("singlesub-async", controller, controller.stream);
-  controller = new StreamController.broadcast();
+  controller = StreamController.broadcast();
   testStream("broadcast-async", controller, controller.stream);
-  controller = new StreamController();
+  controller = StreamController();
   testStream(
       "asbroadcast-async", controller, controller.stream.asBroadcastStream());
 
-  controller = new StreamController(sync: true);
+  controller = StreamController(sync: true);
   testStream("singlesub-sync", controller, controller.stream);
-  controller = new StreamController.broadcast(sync: true);
+  controller = StreamController.broadcast(sync: true);
   testStream("broadcast-sync", controller, controller.stream);
-  controller = new StreamController(sync: true);
+  controller = StreamController(sync: true);
   testStream(
       "asbroadcast-sync", controller, controller.stream.asBroadcastStream());
 }
diff --git a/test/subscription_stream_test.dart b/test/subscription_stream_test.dart
index 804e92f..9460dec 100644
--- a/test/subscription_stream_test.dart
+++ b/test/subscription_stream_test.dart
@@ -13,7 +13,7 @@
   test("subscription stream of an entire subscription", () async {
     var stream = createStream();
     var subscription = stream.listen(null);
-    var subscriptionStream = new SubscriptionStream<int>(subscription);
+    var subscriptionStream = SubscriptionStream<int>(subscription);
     await flushMicrotasks();
     expect(subscriptionStream.toList(), completion([1, 2, 3, 4]));
   });
@@ -21,13 +21,13 @@
   test("subscription stream after two events", () async {
     var stream = createStream();
     var skips = 0;
-    var completer = new Completer();
+    var completer = Completer();
     StreamSubscription<int> subscription;
     subscription = stream.listen((value) {
       ++skips;
       expect(value, skips);
       if (skips == 2) {
-        completer.complete(new SubscriptionStream<int>(subscription));
+        completer.complete(SubscriptionStream<int>(subscription));
       }
     });
     var subscriptionStream = await completer.future;
@@ -38,16 +38,16 @@
   test("listening twice fails", () async {
     var stream = createStream();
     var sourceSubscription = stream.listen(null);
-    var subscriptionStream = new SubscriptionStream<int>(sourceSubscription);
+    var subscriptionStream = SubscriptionStream<int>(sourceSubscription);
     var subscription = subscriptionStream.listen(null);
     expect(() => subscriptionStream.listen(null), throwsA(anything));
     await subscription.cancel();
   });
 
   test("pause and cancel passed through to original stream", () async {
-    var controller = new StreamController(onCancel: () async => 42);
+    var controller = StreamController(onCancel: () async => 42);
     var sourceSubscription = controller.stream.listen(null);
-    var subscriptionStream = new SubscriptionStream(sourceSubscription);
+    var subscriptionStream = SubscriptionStream(sourceSubscription);
     expect(controller.isPaused, isTrue);
     dynamic lastEvent;
     var subscription = subscriptionStream.listen((value) {
@@ -75,16 +75,16 @@
         SubscriptionStream subscriptionStream;
         Future onCancel; // Completes if source stream is canceled before done.
         setUp(() {
-          var cancelCompleter = new Completer();
+          var cancelCompleter = Completer();
           var source = createErrorStream(cancelCompleter);
           onCancel = cancelCompleter.future;
           var sourceSubscription =
               source.listen(null, cancelOnError: sourceCancels);
-          subscriptionStream = new SubscriptionStream<int>(sourceSubscription);
+          subscriptionStream = SubscriptionStream<int>(sourceSubscription);
         });
 
         test("- subscriptionStream: no", () async {
-          var done = new Completer();
+          var done = Completer();
           var events = [];
           subscriptionStream.listen(events.add,
               onError: events.add, onDone: done.complete, cancelOnError: false);
@@ -96,7 +96,7 @@
             done.future.then((_) {
               isDone = true;
             });
-            await new Future.delayed(const Duration(milliseconds: 5));
+            await Future.delayed(const Duration(milliseconds: 5));
             expect(isDone, false);
           } else {
             expected.add(4);
@@ -106,7 +106,7 @@
         });
 
         test("- subscriptionStream: yes", () async {
-          var completer = new Completer();
+          var completer = Completer();
           var events = [];
           subscriptionStream.listen(events.add,
               onError: (value) {
@@ -128,7 +128,7 @@
           var stream = createStream();
           var sourceSubscription =
               stream.listen(null, cancelOnError: cancelOnError);
-          var subscriptionStream = new SubscriptionStream(sourceSubscription);
+          var subscriptionStream = SubscriptionStream(sourceSubscription);
           var subscription =
               subscriptionStream.listen(null, cancelOnError: cancelOnError);
           expect(subscription.asFuture(42), completion(42));
@@ -138,7 +138,7 @@
           var stream = createErrorStream();
           var sourceSubscription =
               stream.listen(null, cancelOnError: cancelOnError);
-          var subscriptionStream = new SubscriptionStream(sourceSubscription);
+          var subscriptionStream = SubscriptionStream(sourceSubscription);
 
           var subscription =
               subscriptionStream.listen(null, cancelOnError: cancelOnError);
@@ -166,7 +166,7 @@
     await flushMicrotasks();
     yield 2;
     await flushMicrotasks();
-    yield* new Future<int>.error("To err is divine!").asStream();
+    yield* Future<int>.error("To err is divine!").asStream();
     await flushMicrotasks();
     yield 4;
     await flushMicrotasks();
diff --git a/test/subscription_transformer_test.dart b/test/subscription_transformer_test.dart
index dbbf597..2a709a4 100644
--- a/test/subscription_transformer_test.dart
+++ b/test/subscription_transformer_test.dart
@@ -13,8 +13,8 @@
   group("with no callbacks", () {
     test("forwards cancellation", () async {
       var isCanceled = false;
-      var cancelCompleter = new Completer();
-      var controller = new StreamController(onCancel: expectAsync0(() {
+      var cancelCompleter = Completer();
+      var controller = StreamController(onCancel: expectAsync0(() {
         isCanceled = true;
         return cancelCompleter.future;
       }));
@@ -40,7 +40,7 @@
     });
 
     test("forwards pausing and resuming", () async {
-      var controller = new StreamController();
+      var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer())
           .listen(expectAsync1((_) {}, count: 0));
@@ -63,12 +63,12 @@
     });
 
     test("forwards pausing with a resume future", () async {
-      var controller = new StreamController();
+      var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer())
           .listen(expectAsync1((_) {}, count: 0));
 
-      var completer = new Completer();
+      var completer = Completer();
       subscription.pause(completer.future);
       await flushMicrotasks();
       expect(controller.isPaused, isTrue);
@@ -83,7 +83,7 @@
     test("invokes the callback when the subscription is canceled", () async {
       var isCanceled = false;
       var callbackInvoked = false;
-      var controller = new StreamController(onCancel: expectAsync0(() {
+      var controller = StreamController(onCancel: expectAsync0(() {
         isCanceled = true;
       }));
       var subscription = controller.stream.transform(
@@ -103,8 +103,8 @@
     });
 
     test("invokes the callback once and caches its result", () async {
-      var completer = new Completer();
-      var controller = new StreamController();
+      var completer = Completer();
+      var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer(
               handleCancel: expectAsync1((inner) => completer.future)))
@@ -134,7 +134,7 @@
   group("with a pause callback", () {
     test("invokes the callback when pause is called", () async {
       var pauseCount = 0;
-      var controller = new StreamController();
+      var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer(
               handlePause: expectAsync1((inner) {
@@ -166,7 +166,7 @@
 
     test("doesn't invoke the callback when the subscription has been canceled",
         () async {
-      var controller = new StreamController();
+      var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer(
               handlePause: expectAsync1((_) {}, count: 0)))
@@ -182,7 +182,7 @@
   group("with a resume callback", () {
     test("invokes the callback when resume is called", () async {
       var resumeCount = 0;
-      var controller = new StreamController();
+      var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer(
               handleResume: expectAsync1((inner) {
@@ -214,14 +214,14 @@
 
     test("invokes the callback when a resume future completes", () async {
       var resumed = false;
-      var controller = new StreamController();
+      var controller = StreamController();
       var subscription = controller.stream.transform(
           subscriptionTransformer(handleResume: expectAsync1((inner) {
         resumed = true;
         inner.resume();
       }))).listen(expectAsync1((_) {}, count: 0));
 
-      var completer = new Completer();
+      var completer = Completer();
       subscription.pause(completer.future);
       await flushMicrotasks();
       expect(resumed, isFalse);
@@ -233,7 +233,7 @@
 
     test("doesn't invoke the callback when the subscription has been canceled",
         () async {
-      var controller = new StreamController();
+      var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer(
               handlePause: expectAsync1((_) {}, count: 0)))
@@ -249,7 +249,7 @@
   group("when the outer subscription is canceled but the inner is not", () {
     StreamSubscription subscription;
     setUp(() {
-      var controller = new StreamController();
+      var controller = StreamController();
       subscription = controller.stream
           .transform(subscriptionTransformer(handleCancel: (_) {}))
           .listen(expectAsync1((_) {}, count: 0),
diff --git a/test/typed_wrapper/stream_subscription_test.dart b/test/typed_wrapper/stream_subscription_test.dart
index 50c07b6..bbec8f7 100644
--- a/test/typed_wrapper/stream_subscription_test.dart
+++ b/test/typed_wrapper/stream_subscription_test.dart
@@ -15,11 +15,10 @@
     StreamSubscription wrapper;
     bool isCanceled;
     setUp(() {
-      controller = new StreamController<Object>(onCancel: () {
+      controller = StreamController<Object>(onCancel: () {
         isCanceled = true;
       });
-      wrapper =
-          new TypeSafeStreamSubscription<int>(controller.stream.listen(null));
+      wrapper = TypeSafeStreamSubscription<int>(controller.stream.listen(null));
     });
 
     test("onData()", () {
@@ -72,11 +71,10 @@
     StreamSubscription wrapper;
     bool isCanceled;
     setUp(() {
-      controller = new StreamController<Object>(onCancel: () {
+      controller = StreamController<Object>(onCancel: () {
         isCanceled = true;
       });
-      wrapper =
-          new TypeSafeStreamSubscription<int>(controller.stream.listen(null));
+      wrapper = TypeSafeStreamSubscription<int>(controller.stream.listen(null));
     });
 
     group("throws a CastError for", () {
@@ -84,9 +82,9 @@
         expect(() {
           // TODO(nweiz): Use the wrapper declared in setUp when sdk#26226 is
           // fixed.
-          controller = new StreamController<Object>();
-          wrapper = new TypeSafeStreamSubscription<int>(
-              controller.stream.listen(null));
+          controller = StreamController<Object>();
+          wrapper =
+              TypeSafeStreamSubscription<int>(controller.stream.listen(null));
 
           wrapper.onData(expectAsync1((_) {}, count: 0));
           controller.add("foo");
diff --git a/test/utils.dart b/test/utils.dart
index 3f8c0ef..e517c78 100644
--- a/test/utils.dart
+++ b/test/utils.dart
@@ -9,9 +9,9 @@
 import "package:test/test.dart";
 
 /// A zero-millisecond timer should wait until after all microtasks.
-Future flushMicrotasks() => new Future.delayed(Duration.zero);
+Future flushMicrotasks() => Future.delayed(Duration.zero);
 
-typedef void OptionalArgAction([a, b]);
+typedef OptionalArgAction = void Function([dynamic a, dynamic b]);
 
 /// A generic unreachable callback function.
 ///
@@ -38,17 +38,17 @@
 
 /// A matcher that runs a callback in its own zone and asserts that that zone
 /// emits a [CastError].
-final throwsZonedCastError = throwsZoned(new TypeMatcher<CastError>());
+final throwsZonedCastError = throwsZoned(TypeMatcher<CastError>());
 
 /// A matcher that matches a callback or future that throws a [CastError].
-final throwsCastError = throwsA(new TypeMatcher<CastError>());
+final throwsCastError = throwsA(TypeMatcher<CastError>());
 
 /// A badly behaved stream which throws if it's ever listened to.
 ///
 /// Can be used to test cases where a stream should not be used.
 class UnusableStream extends Stream {
   listen(onData, {onError, onDone, cancelOnError}) {
-    throw new UnimplementedError("Gotcha!");
+    throw UnimplementedError("Gotcha!");
   }
 }
 
@@ -58,7 +58,7 @@
 /// The [completer] field allows the user to control the future returned by
 /// [done] and [close].
 class CompleterStreamSink<T> implements StreamSink<T> {
-  final completer = new Completer();
+  final completer = Completer();
 
   Future get done => completer.future;
 
@@ -80,7 +80,7 @@
   var _isClosed = false;
 
   Future get done => _doneCompleter.future;
-  final _doneCompleter = new Completer();
+  final _doneCompleter = Completer();
 
   final Function _onDone;
 
@@ -91,22 +91,22 @@
   TestSink({onDone()}) : _onDone = onDone ?? (() {});
 
   void add(T event) {
-    results.add(new Result<T>.value(event));
+    results.add(Result<T>.value(event));
   }
 
   void addError(error, [StackTrace stackTrace]) {
-    results.add(new Result<T>.error(error, stackTrace));
+    results.add(Result<T>.error(error, stackTrace));
   }
 
   Future addStream(Stream<T> stream) {
-    var completer = new Completer.sync();
+    var completer = Completer.sync();
     stream.listen(add, onError: addError, onDone: completer.complete);
     return completer.future;
   }
 
   Future close() {
     _isClosed = true;
-    _doneCompleter.complete(new Future.microtask(_onDone));
+    _doneCompleter.complete(Future.microtask(_onDone));
     return done;
   }
 }