diff --git a/analysis_options.yaml b/analysis_options.yaml
new file mode 100644
index 0000000..bff1a74
--- /dev/null
+++ b/analysis_options.yaml
@@ -0,0 +1,5 @@
+# Defines a default set of lint rules enforced for
+# projects at Google. For details and rationale,
+# see https://github.com/dart-lang/pedantic#enabled-lints.
+include: package:pedantic/analysis_options.yaml
+
diff --git a/lib/error_code.dart b/lib/error_code.dart
index eb2d9be..4bb0808 100644
--- a/lib/error_code.dart
+++ b/lib/error_code.dart
@@ -40,15 +40,15 @@
 String name(int errorCode) {
   switch (errorCode) {
     case PARSE_ERROR:
-      return "parse error";
+      return 'parse error';
     case INVALID_REQUEST:
-      return "invalid request";
+      return 'invalid request';
     case METHOD_NOT_FOUND:
-      return "method not found";
+      return 'method not found';
     case INVALID_PARAMS:
-      return "invalid parameters";
+      return 'invalid parameters';
     case INTERNAL_ERROR:
-      return "internal error";
+      return 'internal error';
     default:
       return null;
   }
diff --git a/lib/src/channel_manager.dart b/lib/src/channel_manager.dart
index 162c9ef..5be11dd 100644
--- a/lib/src/channel_manager.dart
+++ b/lib/src/channel_manager.dart
@@ -25,7 +25,7 @@
   ///
   /// This is the same future that's returned by [listen].
   Future get done => _doneCompleter.future;
-  final _doneCompleter = new Completer.sync();
+  final _doneCompleter = Completer.sync();
 
   /// Whether the underlying communication channel is closed.
   bool get isClosed => _doneCompleter.isCompleted;
@@ -45,9 +45,9 @@
   ///
   /// The returned Future will complete when the input stream is closed. If the
   /// input stream emits an error, that will be piped to the returned Future.
-  Future listen(void handleInput(input)) {
+  Future listen(void Function(dynamic) handleInput) {
     if (_listenCalled) {
-      throw new StateError("Can only call $_name.listen() once.");
+      throw StateError('Can only call $_name.listen() once.');
     }
     _listenCalled = true;
 
diff --git a/lib/src/client.dart b/lib/src/client.dart
index ff5c803..1e421ed 100644
--- a/lib/src/client.dart
+++ b/lib/src/client.dart
@@ -28,7 +28,7 @@
   List _batch;
 
   /// The map of request ids to pending requests.
-  final _pendingRequests = new Map<int, _Request>();
+  final _pendingRequests = <int, _Request>{};
 
   /// Returns a [Future] that completes when the underlying connection is
   /// closed.
@@ -61,11 +61,11 @@
   /// Note that the client won't begin listening to [responses] until
   /// [Client.listen] is called.
   Client.withoutJson(StreamChannel channel)
-      : _manager = new ChannelManager("Client", channel) {
+      : _manager = ChannelManager('Client', channel) {
     _manager.done.whenComplete(() {
       for (var request in _pendingRequests.values) {
         request.completer.completeError(
-            new StateError(
+            StateError(
                 'The client closed with pending request "${request.method}".'),
             StackTrace.current);
       }
@@ -106,8 +106,8 @@
     var id = _id++;
     _send(method, parameters, id);
 
-    var completer = new Completer.sync();
-    _pendingRequests[id] = new _Request(method, completer, new Chain.current());
+    var completer = Completer.sync();
+    _pendingRequests[id] = _Request(method, completer, Chain.current());
     return completer.future;
   }
 
@@ -133,14 +133,14 @@
   void _send(String method, parameters, [int id]) {
     if (parameters is Iterable) parameters = parameters.toList();
     if (parameters is! Map && parameters is! List && parameters != null) {
-      throw new ArgumentError('Only maps and lists may be used as JSON-RPC '
+      throw ArgumentError('Only maps and lists may be used as JSON-RPC '
           'parameters, was "$parameters".');
     }
-    if (isClosed) throw new StateError("The client is closed.");
+    if (isClosed) throw StateError('The client is closed.');
 
-    var message = <String, dynamic>{"jsonrpc": "2.0", "method": method};
-    if (id != null) message["id"] = id;
-    if (parameters != null) message["params"] = parameters;
+    var message = <String, dynamic>{'jsonrpc': '2.0', 'method': method};
+    if (id != null) message['id'] = id;
+    if (parameters != null) message['params'] = parameters;
 
     if (_batch != null) {
       _batch.add(message);
@@ -161,7 +161,7 @@
   /// If this is called in the context of another [withBatch] call, it just
   /// invokes [callback] without creating another batch. This means that
   /// responses are batched until the first batch ends.
-  withBatch(callback()) {
+  void withBatch(Function() callback) {
     if (_batch != null) return callback();
 
     _batch = [];
@@ -184,14 +184,13 @@
   /// resolved.
   void _handleSingleResponse(response) {
     if (!_isResponseValid(response)) return;
-    var request = _pendingRequests.remove(response["id"]);
-    if (response.containsKey("result")) {
-      request.completer.complete(response["result"]);
+    var request = _pendingRequests.remove(response['id']);
+    if (response.containsKey('result')) {
+      request.completer.complete(response['result']);
     } else {
       request.completer.completeError(
-          new RpcException(
-              response["error"]["code"], response["error"]["message"],
-              data: response["error"]["data"]),
+          RpcException(response['error']['code'], response['error']['message'],
+              data: response['error']['data']),
           request.chain);
     }
   }
@@ -199,15 +198,15 @@
   /// Determines whether the server's response is valid per the spec.
   bool _isResponseValid(response) {
     if (response is! Map) return false;
-    if (response["jsonrpc"] != "2.0") return false;
-    if (!_pendingRequests.containsKey(response["id"])) return false;
-    if (response.containsKey("result")) return true;
+    if (response['jsonrpc'] != '2.0') return false;
+    if (!_pendingRequests.containsKey(response['id'])) return false;
+    if (response.containsKey('result')) return true;
 
-    if (!response.containsKey("error")) return false;
-    var error = response["error"];
+    if (!response.containsKey('error')) return false;
+    var error = response['error'];
     if (error is! Map) return false;
-    if (error["code"] is! int) return false;
-    if (error["message"] is! String) return false;
+    if (error['code'] is! int) return false;
+    if (error['message'] is! String) return false;
     return true;
   }
 }
diff --git a/lib/src/exception.dart b/lib/src/exception.dart
index b359155..64c97d0 100644
--- a/lib/src/exception.dart
+++ b/lib/src/exception.dart
@@ -43,10 +43,10 @@
 
   /// Converts this exception into a JSON-serializable object that's a valid
   /// JSON-RPC 2.0 error response.
-  serialize(request) {
+  Map<String, dynamic> serialize(request) {
     var modifiedData;
     if (data is Map && !data.containsKey('request')) {
-      modifiedData = new Map.from(data);
+      modifiedData = Map.from(data);
       modifiedData['request'] = request;
     } else if (data == null) {
       modifiedData = {'request': request};
@@ -63,10 +63,11 @@
     };
   }
 
+  @override
   String toString() {
-    var prefix = "JSON-RPC error $code";
+    var prefix = 'JSON-RPC error $code';
     var errorName = error_code.name(code);
-    if (errorName != null) prefix += " ($errorName)";
-    return "$prefix: $message";
+    if (errorName != null) prefix += ' ($errorName)';
+    return '$prefix: $message';
   }
 }
diff --git a/lib/src/parameters.dart b/lib/src/parameters.dart
index 8b39d46..665765b 100644
--- a/lib/src/parameters.dart
+++ b/lib/src/parameters.dart
@@ -26,7 +26,7 @@
   ///
   /// If this is accessed for a [Parameter] that was not passed, the request
   /// will be automatically rejected. To avoid this, use [Parameter.valueOr].
-  get value => _value;
+  dynamic get value => _value;
   final _value;
 
   Parameters(this.method, this._value);
@@ -48,19 +48,19 @@
     if (key is int) {
       _assertPositional();
       if (key < value.length) {
-        return new Parameter._(method, value[key], this, key);
+        return Parameter._(method, value[key], this, key);
       } else {
-        return new _MissingParameter(method, this, key);
+        return _MissingParameter(method, this, key);
       }
     } else if (key is String) {
       _assertNamed();
       if (value.containsKey(key)) {
-        return new Parameter._(method, value[key], this, key);
+        return Parameter._(method, value[key], this, key);
       } else {
-        return new _MissingParameter(method, this, key);
+        return _MissingParameter(method, this, key);
       }
     } else {
-      throw new ArgumentError('Parameters[] only takes an int or a string, was '
+      throw ArgumentError('Parameters[] only takes an int or a string, was '
           '"$key".');
     }
   }
@@ -80,14 +80,14 @@
   /// Asserts that [value] is a positional argument list.
   void _assertPositional() {
     if (value is List) return;
-    throw new RpcException.invalidParams('Parameters for method "$method" '
+    throw RpcException.invalidParams('Parameters for method "$method" '
         'must be passed by position.');
   }
 
   /// Asserts that [value] is a named argument map.
   void _assertNamed() {
     if (value is Map) return;
-    throw new RpcException.invalidParams('Parameters for method "$method" '
+    throw RpcException.invalidParams('Parameters for method "$method" '
         'must be passed by name.');
   }
 }
@@ -131,20 +131,20 @@
       return _key is int ? (_key + 1).toString() : jsonEncode(_key);
     }
 
-    quoteKey(key) {
-      if (key.contains(new RegExp(r'[^a-zA-Z0-9_-]'))) return jsonEncode(key);
+    String quoteKey(key) {
+      if (key.contains(RegExp(r'[^a-zA-Z0-9_-]'))) return jsonEncode(key);
       return key;
     }
 
-    computePath(params) {
+    String computePath(params) {
       if (params._parent is! Parameter) {
-        return params._key is int ? "[${params._key}]" : quoteKey(params._key);
+        return params._key is int ? '[${params._key}]' : quoteKey(params._key);
       }
 
       var path = computePath(params._parent);
       return params._key is int
-          ? "$path[${params._key}]"
-          : "$path.${quoteKey(params._key)}";
+          ? '$path[${params._key}]'
+          : '$path.${quoteKey(params._key)}';
     }
 
     return computePath(this);
@@ -157,7 +157,7 @@
       : super(method, value);
 
   /// Returns [value], or [defaultValue] if this parameter wasn't passed.
-  valueOr(defaultValue) => value;
+  dynamic valueOr(defaultValue) => value;
 
   /// Asserts that [value] exists and is a number and returns it.
   ///
@@ -215,6 +215,7 @@
   ///
   /// [asListOr] may be used to provide a default value instead of rejecting the
   /// request if [value] doesn't exist.
+  @override
   List get asList => _getTyped('an Array', (value) => value is List);
 
   /// Asserts that [value] is a [List] and returns it.
@@ -226,6 +227,7 @@
   ///
   /// [asMapOr] may be used to provide a default value instead of rejecting the
   /// request if [value] doesn't exist.
+  @override
   Map get asMap => _getTyped('an Object', (value) => value is Map);
 
   /// Asserts that [value] is a [Map] and returns it.
@@ -264,13 +266,13 @@
   ///
   /// [type] is used for the error message. It should begin with an indefinite
   /// article.
-  _getTyped(String type, bool test(value)) {
+  dynamic _getTyped(String type, bool Function(dynamic) test) {
     if (test(value)) return value;
-    throw new RpcException.invalidParams('Parameter $_path for method '
+    throw RpcException.invalidParams('Parameter $_path for method '
         '"$method" must be $type, but was ${jsonEncode(value)}.');
   }
 
-  _getParsed(String description, parse(String value)) {
+  dynamic _getParsed(String description, Function(String) parse) {
     var string = asString;
     try {
       return parse(string);
@@ -285,17 +287,19 @@
         message = '\n$message';
       }
 
-      throw new RpcException.invalidParams('Parameter $_path for method '
+      throw RpcException.invalidParams('Parameter $_path for method '
           '"$method" must be a valid $description, but was '
           '${jsonEncode(string)}.$message');
     }
   }
 
+  @override
   void _assertPositional() {
     // Throw the standard exception for a mis-typed list.
     asList;
   }
 
+  @override
   void _assertNamed() {
     // Throw the standard exception for a mis-typed map.
     asMap;
@@ -304,31 +308,42 @@
 
 /// A subclass of [Parameter] representing a missing parameter.
 class _MissingParameter extends Parameter {
-  get value {
-    throw new RpcException.invalidParams('Request for method "$method" is '
+  @override
+  dynamic get value {
+    throw RpcException.invalidParams('Request for method "$method" is '
         'missing required parameter $_path.');
   }
 
+  @override
   bool get exists => false;
 
   _MissingParameter(String method, Parameters parent, key)
       : super._(method, null, parent, key);
 
-  valueOr(defaultValue) => defaultValue;
+  @override
+  dynamic valueOr(defaultValue) => defaultValue;
 
+  @override
   num asNumOr(num defaultValue) => defaultValue;
 
+  @override
   int asIntOr(int defaultValue) => defaultValue;
 
+  @override
   bool asBoolOr(bool defaultValue) => defaultValue;
 
+  @override
   String asStringOr(String defaultValue) => defaultValue;
 
+  @override
   List asListOr(List defaultValue) => defaultValue;
 
+  @override
   Map asMapOr(Map defaultValue) => defaultValue;
 
+  @override
   DateTime asDateTimeOr(DateTime defaultValue) => defaultValue;
 
+  @override
   Uri asUriOr(Uri defaultValue) => defaultValue;
 }
diff --git a/lib/src/peer.dart b/lib/src/peer.dart
index 7176763..cd51a7c 100644
--- a/lib/src/peer.dart
+++ b/lib/src/peer.dart
@@ -30,13 +30,15 @@
 
   /// A stream controller that forwards incoming messages to [_server] if
   /// they're requests.
-  final _serverIncomingForwarder = new StreamController(sync: true);
+  final _serverIncomingForwarder = StreamController(sync: true);
 
   /// A stream controller that forwards incoming messages to [_client] if
   /// they're responses.
-  final _clientIncomingForwarder = new StreamController(sync: true);
+  final _clientIncomingForwarder = StreamController(sync: true);
 
+  @override
   Future get done => _manager.done;
+  @override
   bool get isClosed => _manager.isClosed;
 
   @override
@@ -65,34 +67,40 @@
   /// Unhandled exceptions in callbacks will be forwarded to [onUnhandledError].
   /// If this is not provided, unhandled exceptions will be swallowed.
   Peer.withoutJson(StreamChannel channel, {ErrorCallback onUnhandledError})
-      : _manager = new ChannelManager("Peer", channel) {
-    _server = new Server.withoutJson(
-        new StreamChannel(_serverIncomingForwarder.stream, channel.sink),
+      : _manager = ChannelManager('Peer', channel) {
+    _server = Server.withoutJson(
+        StreamChannel(_serverIncomingForwarder.stream, channel.sink),
         onUnhandledError: onUnhandledError);
-    _client = new Client.withoutJson(
-        new StreamChannel(_clientIncomingForwarder.stream, channel.sink));
+    _client = Client.withoutJson(
+        StreamChannel(_clientIncomingForwarder.stream, channel.sink));
   }
 
   // Client methods.
 
+  @override
   Future sendRequest(String method, [parameters]) =>
       _client.sendRequest(method, parameters);
 
+  @override
   void sendNotification(String method, [parameters]) =>
       _client.sendNotification(method, parameters);
 
-  withBatch(callback()) => _client.withBatch(callback);
+  @override
+  void withBatch(Function() callback) => _client.withBatch(callback);
 
   // Server methods.
 
+  @override
   void registerMethod(String name, Function callback) =>
       _server.registerMethod(name, callback);
 
-  void registerFallback(callback(Parameters parameters)) =>
+  @override
+  void registerFallback(Function(Parameters parameters) callback) =>
       _server.registerFallback(callback);
 
   // Shared methods.
 
+  @override
   Future listen() {
     _client.listen();
     _server.listen();
@@ -120,6 +128,7 @@
     });
   }
 
+  @override
   Future close() =>
       Future.wait([_client.close(), _server.close(), _manager.close()]);
 }
diff --git a/lib/src/server.dart b/lib/src/server.dart
index 5c3b132..30da924 100644
--- a/lib/src/server.dart
+++ b/lib/src/server.dart
@@ -32,13 +32,13 @@
   final ChannelManager _manager;
 
   /// The methods registered for this server.
-  final _methods = new Map<String, Function>();
+  final _methods = <String, Function>{};
 
   /// The fallback methods for this server.
   ///
   /// These are tried in order until one of them doesn't throw a
   /// [RpcException.methodNotFound] exception.
-  final _fallbacks = new Queue<Function>();
+  final _fallbacks = Queue<Function>();
 
   /// Returns a [Future] that completes when the underlying connection is
   /// closed.
@@ -85,7 +85,7 @@
   /// Unhandled exceptions in callbacks will be forwarded to [onUnhandledError].
   /// If this is not provided, unhandled exceptions will be swallowed.
   Server.withoutJson(StreamChannel channel, {this.onUnhandledError})
-      : _manager = new ChannelManager("Server", channel);
+      : _manager = ChannelManager('Server', channel);
 
   /// Starts listening to the underlying stream.
   ///
@@ -112,7 +112,7 @@
   /// reported to the client as JSON-RPC 2.0 errors.
   void registerMethod(String name, Function callback) {
     if (_methods.containsKey(name)) {
-      throw new ArgumentError('There\'s already a method named "$name".');
+      throw ArgumentError('There\'s already a method named "$name".');
     }
 
     _methods[name] = callback;
@@ -129,7 +129,7 @@
   /// completes to a JSON-serializable object. Any errors in [callback] will be
   /// reported to the client as JSON-RPC 2.0 errors. [callback] may send custom
   /// errors by throwing an [RpcException].
-  void registerFallback(callback(Parameters parameters)) {
+  void registerFallback(Function(Parameters parameters) callback) {
     _fallbacks.add(callback);
   }
 
@@ -144,7 +144,7 @@
     var response;
     if (request is List) {
       if (request.isEmpty) {
-        response = new RpcException(error_code.INVALID_REQUEST,
+        response = RpcException(error_code.INVALID_REQUEST,
                 'A batch must contain at least one request.')
             .serialize(request);
       } else {
@@ -168,17 +168,17 @@
 
       var name = request['method'];
       var method = _methods[name];
-      if (method == null) method = _tryFallbacks;
+      method ??= _tryFallbacks;
 
       Object result;
       if (method is ZeroArgumentFunction) {
         if (request.containsKey('params')) {
-          throw new RpcException.invalidParams('No parameters are allowed for '
+          throw RpcException.invalidParams('No parameters are allowed for '
               'method "$name".');
         }
         result = await method();
       } else {
-        result = await method(new Parameters(name, request['params']));
+        result = await method(Parameters(name, request['params']));
       }
 
       // A request without an id is a notification, which should not be sent a
@@ -199,8 +199,8 @@
         onUnhandledError?.call(error, stackTrace);
         return null;
       }
-      final chain = new Chain.forTrace(stackTrace);
-      return new RpcException(error_code.SERVER_ERROR, getErrorMessage(error),
+      final chain = Chain.forTrace(stackTrace);
+      return RpcException(error_code.SERVER_ERROR, getErrorMessage(error),
           data: {
             'full': '$error',
             'stack': '$chain',
@@ -211,28 +211,28 @@
   /// Validates that [request] matches the JSON-RPC spec.
   void _validateRequest(request) {
     if (request is! Map) {
-      throw new RpcException(
+      throw RpcException(
           error_code.INVALID_REQUEST,
           'Request must be '
           'an Array or an Object.');
     }
 
     if (!request.containsKey('jsonrpc')) {
-      throw new RpcException(
+      throw RpcException(
           error_code.INVALID_REQUEST,
           'Request must '
           'contain a "jsonrpc" key.');
     }
 
     if (request['jsonrpc'] != '2.0') {
-      throw new RpcException(
+      throw RpcException(
           error_code.INVALID_REQUEST,
           'Invalid JSON-RPC '
           'version ${jsonEncode(request['jsonrpc'])}, expected "2.0".');
     }
 
     if (!request.containsKey('method')) {
-      throw new RpcException(
+      throw RpcException(
           error_code.INVALID_REQUEST,
           'Request must '
           'contain a "method" key.');
@@ -240,7 +240,7 @@
 
     var method = request['method'];
     if (request['method'] is! String) {
-      throw new RpcException(
+      throw RpcException(
           error_code.INVALID_REQUEST,
           'Request method must '
           'be a string, but was ${jsonEncode(method)}.');
@@ -248,7 +248,7 @@
 
     var params = request['params'];
     if (request.containsKey('params') && params is! List && params is! Map) {
-      throw new RpcException(
+      throw RpcException(
           error_code.INVALID_REQUEST,
           'Request params must '
           'be an Array or an Object, but was ${jsonEncode(params)}.');
@@ -256,7 +256,7 @@
 
     var id = request['id'];
     if (id != null && id is! String && id is! num) {
-      throw new RpcException(
+      throw RpcException(
           error_code.INVALID_REQUEST,
           'Request id must be a '
           'string, number, or null, but was ${jsonEncode(id)}.');
@@ -267,16 +267,16 @@
   Future _tryFallbacks(Parameters params) {
     var iterator = _fallbacks.toList().iterator;
 
-    _tryNext() async {
+    Future _tryNext() async {
       if (!iterator.moveNext()) {
-        throw new RpcException.methodNotFound(params.method);
+        throw RpcException.methodNotFound(params.method);
       }
 
       try {
         return iterator.current(params);
       } on RpcException catch (error) {
-        if (error is! RpcException) throw error;
-        if (error.code != error_code.METHOD_NOT_FOUND) throw error;
+        if (error is! RpcException) rethrow;
+        if (error.code != error_code.METHOD_NOT_FOUND) rethrow;
         return _tryNext();
       }
     }
diff --git a/lib/src/utils.dart b/lib/src/utils.dart
index 1e2d6b1..f1989a7 100644
--- a/lib/src/utils.dart
+++ b/lib/src/utils.dart
@@ -9,7 +9,7 @@
 import '../error_code.dart' as error_code;
 import 'exception.dart';
 
-typedef ZeroArgumentFunction();
+typedef ZeroArgumentFunction = Function();
 
 /// Returns a sentence fragment listing the elements of [iter].
 ///
@@ -17,7 +17,7 @@
 /// commas and/or "and" where appropriate.
 String toSentence(Iterable iter) {
   if (iter.length == 1) return iter.first.toString();
-  return iter.take(iter.length - 1).join(", ") + " and ${iter.last}";
+  return iter.take(iter.length - 1).join(', ') + ' and ${iter.last}';
 }
 
 /// Returns [name] if [number] is 1, or the plural of [name] otherwise.
@@ -32,7 +32,7 @@
 
 /// A regular expression to match the exception prefix that some exceptions'
 /// [Object.toString] values contain.
-final _exceptionPrefix = new RegExp(r'^([A-Z][a-zA-Z]*)?(Exception|Error): ');
+final _exceptionPrefix = RegExp(r'^([A-Z][a-zA-Z]*)?(Exception|Error): ');
 
 /// Get a string description of an exception.
 ///
@@ -46,7 +46,7 @@
 ///
 /// This is synchronicity-agnostic relative to [body]. If [body] returns a
 /// [Future], this wil run asynchronously; otherwise it will run synchronously.
-tryFinally(body(), whenComplete()) {
+void tryFinally(Function() body, Function() whenComplete) {
   var result;
   try {
     result = body();
@@ -64,27 +64,27 @@
 }
 
 /// A transformer that silently drops [FormatException]s.
-final ignoreFormatExceptions =
-    new StreamTransformer<Object, Object>.fromHandlers(
-        handleError: (error, stackTrace, sink) {
+final ignoreFormatExceptions = StreamTransformer<Object, Object>.fromHandlers(
+    handleError: (error, stackTrace, sink) {
   if (error is FormatException) return;
   sink.addError(error, stackTrace);
 });
 
 /// A transformer that sends error responses on [FormatException]s.
 final StreamChannelTransformer respondToFormatExceptions =
-    new _RespondToFormatExceptionsTransformer();
+    _RespondToFormatExceptionsTransformer();
 
 /// The implementation of [respondToFormatExceptions].
 class _RespondToFormatExceptionsTransformer
     implements StreamChannelTransformer {
+  @override
   StreamChannel bind(StreamChannel channel) {
     var transformed;
     transformed = channel.changeStream((stream) {
       return stream.handleError((error) {
         if (error is! FormatException) throw error;
 
-        var exception = new RpcException(
+        var exception = RpcException(
             error_code.PARSE_ERROR, 'Invalid JSON: ${error.message}');
         transformed.sink.add(exception.serialize(error.source));
       });
@@ -95,21 +95,26 @@
 
 /// Returns a [StreamSink] that wraps [sink] and maps each event added using
 /// [callback].
-StreamSink mapStreamSink(StreamSink sink, callback(event)) =>
-    new _MappedStreamSink(sink, callback);
+StreamSink mapStreamSink(StreamSink sink, Function(dynamic) callback) =>
+    _MappedStreamSink(sink, callback);
 
 /// A [StreamSink] wrapper that maps each event added to the sink.
 class _MappedStreamSink implements StreamSink {
   final StreamSink _inner;
   final Function _callback;
 
+  @override
   Future get done => _inner.done;
 
   _MappedStreamSink(this._inner, this._callback);
 
+  @override
   void add(event) => _inner.add(_callback(event));
+  @override
   void addError(error, [StackTrace stackTrace]) =>
       _inner.addError(error, stackTrace);
+  @override
   Future addStream(Stream stream) => _inner.addStream(stream.map(_callback));
+  @override
   Future close() => _inner.close();
 }
diff --git a/pubspec.yaml b/pubspec.yaml
index 40c0293..5e8e29c 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -13,4 +13,5 @@
   stream_channel: ">=1.1.0 <3.0.0"
 
 dev_dependencies:
+  pedantic: ^1.8.0
   test: ^1.0.0
diff --git a/test/client/client_test.dart b/test/client/client_test.dart
index 358247d..c1edbe4 100644
--- a/test/client/client_test.dart
+++ b/test/client/client_test.dart
@@ -12,9 +12,9 @@
 
 void main() {
   var controller;
-  setUp(() => controller = new ClientController());
+  setUp(() => controller = ClientController());
 
-  test("sends a message and returns the response", () {
+  test('sends a message and returns the response', () {
     controller.expectRequest((request) {
       expect(
           request,
@@ -27,11 +27,11 @@
       return {'jsonrpc': '2.0', 'result': 'bar', 'id': request['id']};
     });
 
-    expect(controller.client.sendRequest("foo", {'param': 'value'}),
+    expect(controller.client.sendRequest('foo', {'param': 'value'}),
         completion(equals('bar')));
   });
 
-  test("sends a notification and expects no response", () {
+  test('sends a notification and expects no response', () {
     controller.expectRequest((request) {
       expect(
           request,
@@ -42,10 +42,10 @@
           }));
     });
 
-    controller.client.sendNotification("foo", {'param': 'value'});
+    controller.client.sendNotification('foo', {'param': 'value'});
   });
 
-  test("sends a notification with positional parameters", () {
+  test('sends a notification with positional parameters', () {
     controller.expectRequest((request) {
       expect(
           request,
@@ -56,20 +56,20 @@
           }));
     });
 
-    controller.client.sendNotification("foo", ['value1', 'value2']);
+    controller.client.sendNotification('foo', ['value1', 'value2']);
   });
 
-  test("sends a notification with no parameters", () {
+  test('sends a notification with no parameters', () {
     controller.expectRequest((request) {
       expect(request, equals({'jsonrpc': '2.0', 'method': 'foo'}));
     });
 
-    controller.client.sendNotification("foo");
+    controller.client.sendNotification('foo');
   });
 
-  test("sends a synchronous batch of requests", () {
+  test('sends a synchronous batch of requests', () {
     controller.expectRequest((request) {
-      expect(request, new TypeMatcher<List>());
+      expect(request, TypeMatcher<List>());
       expect(request, hasLength(3));
       expect(request[0], equals({'jsonrpc': '2.0', 'method': 'foo'}));
       expect(
@@ -91,17 +91,17 @@
     });
 
     controller.client.withBatch(() {
-      controller.client.sendNotification("foo");
-      expect(controller.client.sendRequest("bar", {'param': 'value'}),
-          completion(equals("bar response")));
-      expect(controller.client.sendRequest("baz"),
-          completion(equals("baz response")));
+      controller.client.sendNotification('foo');
+      expect(controller.client.sendRequest('bar', {'param': 'value'}),
+          completion(equals('bar response')));
+      expect(controller.client.sendRequest('baz'),
+          completion(equals('baz response')));
     });
   });
 
-  test("sends an asynchronous batch of requests", () {
+  test('sends an asynchronous batch of requests', () {
     controller.expectRequest((request) {
-      expect(request, new TypeMatcher<List>());
+      expect(request, TypeMatcher<List>());
       expect(request, hasLength(3));
       expect(request[0], equals({'jsonrpc': '2.0', 'method': 'foo'}));
       expect(
@@ -123,21 +123,21 @@
     });
 
     controller.client.withBatch(() {
-      return new Future.value().then((_) {
-        controller.client.sendNotification("foo");
-        return new Future.value();
+      return Future.value().then((_) {
+        controller.client.sendNotification('foo');
+        return Future.value();
       }).then((_) {
-        expect(controller.client.sendRequest("bar", {'param': 'value'}),
-            completion(equals("bar response")));
-        return new Future.value();
+        expect(controller.client.sendRequest('bar', {'param': 'value'}),
+            completion(equals('bar response')));
+        return Future.value();
       }).then((_) {
-        expect(controller.client.sendRequest("baz"),
-            completion(equals("baz response")));
+        expect(controller.client.sendRequest('baz'),
+            completion(equals('baz response')));
       });
     });
   });
 
-  test("reports an error from the server", () {
+  test('reports an error from the server', () {
     controller.expectRequest((request) {
       expect(
           request,
@@ -155,9 +155,9 @@
       };
     });
 
-    expect(controller.client.sendRequest("foo", {'param': 'value'}),
+    expect(controller.client.sendRequest('foo', {'param': 'value'}),
         throwsA(predicate((exception) {
-      expect(exception, new TypeMatcher<json_rpc.RpcException>());
+      expect(exception, TypeMatcher<json_rpc.RpcException>());
       expect(exception.code, equals(error_code.SERVER_ERROR));
       expect(exception.message, equals('you are bad at requests'));
       expect(exception.data, equals('some junk'));
@@ -165,17 +165,17 @@
     })));
   });
 
-  test("requests throw StateErrors if the client is closed", () {
+  test('requests throw StateErrors if the client is closed', () {
     controller.client.close();
-    expect(() => controller.client.sendRequest("foo"), throwsStateError);
-    expect(() => controller.client.sendNotification("foo"), throwsStateError);
+    expect(() => controller.client.sendRequest('foo'), throwsStateError);
+    expect(() => controller.client.sendNotification('foo'), throwsStateError);
   });
 
-  test("ignores bogus responses", () {
+  test('ignores bogus responses', () {
     // Make a request so we have something to respond to.
     controller.expectRequest((request) {
-      controller.sendJsonResponse("{invalid");
-      controller.sendResponse("not a map");
+      controller.sendJsonResponse('{invalid');
+      controller.sendResponse('not a map');
       controller.sendResponse(
           {'jsonrpc': 'wrong version', 'result': 'wrong', 'id': request['id']});
       controller.sendResponse({'jsonrpc': '2.0', 'result': 'wrong'});
@@ -197,6 +197,6 @@
           (_) => {'jsonrpc': '2.0', 'result': 'right', 'id': request['id']});
     });
 
-    expect(controller.client.sendRequest("foo"), completion(equals('right')));
+    expect(controller.client.sendRequest('foo'), completion(equals('right')));
   });
 }
diff --git a/test/client/stream_test.dart b/test/client/stream_test.dart
index 94a0604..4080064 100644
--- a/test/client/stream_test.dart
+++ b/test/client/stream_test.dart
@@ -14,13 +14,13 @@
   var requestController;
   var client;
   setUp(() {
-    responseController = new StreamController();
-    requestController = new StreamController();
-    client = new json_rpc.Client.withoutJson(
-        new StreamChannel(responseController.stream, requestController.sink));
+    responseController = StreamController();
+    requestController = StreamController();
+    client = json_rpc.Client.withoutJson(
+        StreamChannel(responseController.stream, requestController.sink));
   });
 
-  test(".withoutJson supports decoded stream and sink", () {
+  test('.withoutJson supports decoded stream and sink', () {
     client.listen();
 
     expect(requestController.stream.first.then((request) {
@@ -36,7 +36,7 @@
     client.sendRequest('foo');
   });
 
-  test(".listen returns when the controller is closed", () {
+  test('.listen returns when the controller is closed', () {
     var hasListenCompeted = false;
     expect(client.listen().then((_) => hasListenCompeted = true), completes);
 
@@ -48,17 +48,17 @@
     });
   });
 
-  test(".listen returns a stream error", () {
+  test('.listen returns a stream error', () {
     expect(client.listen(), throwsA('oh no'));
     responseController.addError('oh no');
   });
 
-  test(".listen can't be called twice", () {
+  test('.listen can\'t be called twice', () {
     client.listen();
     expect(() => client.listen(), throwsStateError);
   });
 
-  test(".close cancels the stream subscription and closes the sink", () {
+  test('.close cancels the stream subscription and closes the sink', () {
     // Work around sdk#19095.
     requestController.stream.listen(null);
 
@@ -72,22 +72,22 @@
     expect(requestController.isClosed, isTrue);
   });
 
-  group("a stream error", () {
-    test("is reported through .done", () {
-      expect(client.listen(), throwsA("oh no!"));
-      expect(client.done, throwsA("oh no!"));
-      responseController.addError("oh no!");
+  group('a stream error', () {
+    test('is reported through .done', () {
+      expect(client.listen(), throwsA('oh no!'));
+      expect(client.done, throwsA('oh no!'));
+      responseController.addError('oh no!');
     });
 
-    test("cause a pending request to throw a StateError", () {
-      expect(client.listen(), throwsA("oh no!"));
+    test('cause a pending request to throw a StateError', () {
+      expect(client.listen(), throwsA('oh no!'));
       expect(client.sendRequest('foo'), throwsStateError);
-      responseController.addError("oh no!");
+      responseController.addError('oh no!');
     });
 
-    test("causes future requests to throw StateErrors", () async {
-      expect(client.listen(), throwsA("oh no!"));
-      responseController.addError("oh no!");
+    test('causes future requests to throw StateErrors', () async {
+      expect(client.listen(), throwsA('oh no!'));
+      responseController.addError('oh no!');
       await pumpEventQueue();
 
       expect(() => client.sendRequest('foo'), throwsStateError);
diff --git a/test/client/utils.dart b/test/client/utils.dart
index 8a0a9a3..1684b37 100644
--- a/test/client/utils.dart
+++ b/test/client/utils.dart
@@ -13,18 +13,18 @@
 /// A controller used to test a [json_rpc.Client].
 class ClientController {
   /// The controller for the client's response stream.
-  final _responseController = new StreamController<String>();
+  final _responseController = StreamController<String>();
 
   /// The controller for the client's request sink.
-  final _requestController = new StreamController<String>();
+  final _requestController = StreamController<String>();
 
   /// The client.
   json_rpc.Client get client => _client;
   json_rpc.Client _client;
 
   ClientController() {
-    _client = new json_rpc.Client(
-        new StreamChannel(_responseController.stream, _requestController.sink));
+    _client = json_rpc.Client(
+        StreamChannel(_responseController.stream, _requestController.sink));
     _client.listen();
   }
 
@@ -34,7 +34,7 @@
   /// returns a String, that's sent as the response directly. If it returns
   /// null, no response is sent. Otherwise, the return value is encoded and sent
   /// as the response.
-  void expectRequest(callback(request)) {
+  void expectRequest(Function(dynamic) callback) {
     expect(
         _requestController.stream.first.then((request) {
           return callback(jsonDecode(request));
diff --git a/test/peer_test.dart b/test/peer_test.dart
index 491526f..33184b0 100644
--- a/test/peer_test.dart
+++ b/test/peer_test.dart
@@ -16,62 +16,62 @@
   var outgoing;
   var peer;
   setUp(() {
-    var incomingController = new StreamController();
+    var incomingController = StreamController();
     incoming = incomingController.sink;
-    var outgoingController = new StreamController();
+    var outgoingController = StreamController();
     outgoing = outgoingController.stream;
-    peer = new json_rpc.Peer.withoutJson(
-        new StreamChannel(incomingController.stream, outgoingController));
+    peer = json_rpc.Peer.withoutJson(
+        StreamChannel(incomingController.stream, outgoingController));
   });
 
-  group("like a client,", () {
-    test("can send a message and receive a response", () {
+  group('like a client,', () {
+    test('can send a message and receive a response', () {
       expect(outgoing.first.then((request) {
         expect(
             request,
             equals({
-              "jsonrpc": "2.0",
-              "method": "foo",
-              "params": {"bar": "baz"},
-              "id": 0
+              'jsonrpc': '2.0',
+              'method': 'foo',
+              'params': {'bar': 'baz'},
+              'id': 0
             }));
-        incoming.add({"jsonrpc": "2.0", "result": "qux", "id": 0});
+        incoming.add({'jsonrpc': '2.0', 'result': 'qux', 'id': 0});
       }), completes);
 
       peer.listen();
       expect(
-          peer.sendRequest("foo", {"bar": "baz"}), completion(equals("qux")));
+          peer.sendRequest('foo', {'bar': 'baz'}), completion(equals('qux')));
     });
 
-    test("can send a batch of messages and receive a batch of responses", () {
+    test('can send a batch of messages and receive a batch of responses', () {
       expect(outgoing.first.then((request) {
         expect(
             request,
             equals([
               {
-                "jsonrpc": "2.0",
-                "method": "foo",
-                "params": {"bar": "baz"},
-                "id": 0
+                'jsonrpc': '2.0',
+                'method': 'foo',
+                'params': {'bar': 'baz'},
+                'id': 0
               },
               {
-                "jsonrpc": "2.0",
-                "method": "a",
-                "params": {"b": "c"},
-                "id": 1
+                'jsonrpc': '2.0',
+                'method': 'a',
+                'params': {'b': 'c'},
+                'id': 1
               },
               {
-                "jsonrpc": "2.0",
-                "method": "w",
-                "params": {"x": "y"},
-                "id": 2
+                'jsonrpc': '2.0',
+                'method': 'w',
+                'params': {'x': 'y'},
+                'id': 2
               }
             ]));
 
         incoming.add([
-          {"jsonrpc": "2.0", "result": "qux", "id": 0},
-          {"jsonrpc": "2.0", "result": "d", "id": 1},
-          {"jsonrpc": "2.0", "result": "z", "id": 2}
+          {'jsonrpc': '2.0', 'result': 'qux', 'id': 0},
+          {'jsonrpc': '2.0', 'result': 'd', 'id': 1},
+          {'jsonrpc': '2.0', 'result': 'z', 'id': 2}
         ]);
       }), completes);
 
@@ -79,119 +79,119 @@
 
       peer.withBatch(() {
         expect(
-            peer.sendRequest("foo", {"bar": "baz"}), completion(equals("qux")));
-        expect(peer.sendRequest("a", {"b": "c"}), completion(equals("d")));
-        expect(peer.sendRequest("w", {"x": "y"}), completion(equals("z")));
+            peer.sendRequest('foo', {'bar': 'baz'}), completion(equals('qux')));
+        expect(peer.sendRequest('a', {'b': 'c'}), completion(equals('d')));
+        expect(peer.sendRequest('w', {'x': 'y'}), completion(equals('z')));
       });
     });
   });
 
-  group("like a server,", () {
-    test("can receive a call and return a response", () {
+  group('like a server,', () {
+    test('can receive a call and return a response', () {
       expect(outgoing.first,
-          completion(equals({"jsonrpc": "2.0", "result": "qux", "id": 0})));
+          completion(equals({'jsonrpc': '2.0', 'result': 'qux', 'id': 0})));
 
-      peer.registerMethod("foo", (_) => "qux");
+      peer.registerMethod('foo', (_) => 'qux');
       peer.listen();
 
       incoming.add({
-        "jsonrpc": "2.0",
-        "method": "foo",
-        "params": {"bar": "baz"},
-        "id": 0
+        'jsonrpc': '2.0',
+        'method': 'foo',
+        'params': {'bar': 'baz'},
+        'id': 0
       });
     });
 
-    test("can receive a batch of calls and return a batch of responses", () {
+    test('can receive a batch of calls and return a batch of responses', () {
       expect(
           outgoing.first,
           completion(equals([
-            {"jsonrpc": "2.0", "result": "qux", "id": 0},
-            {"jsonrpc": "2.0", "result": "d", "id": 1},
-            {"jsonrpc": "2.0", "result": "z", "id": 2}
+            {'jsonrpc': '2.0', 'result': 'qux', 'id': 0},
+            {'jsonrpc': '2.0', 'result': 'd', 'id': 1},
+            {'jsonrpc': '2.0', 'result': 'z', 'id': 2}
           ])));
 
-      peer.registerMethod("foo", (_) => "qux");
-      peer.registerMethod("a", (_) => "d");
-      peer.registerMethod("w", (_) => "z");
+      peer.registerMethod('foo', (_) => 'qux');
+      peer.registerMethod('a', (_) => 'd');
+      peer.registerMethod('w', (_) => 'z');
       peer.listen();
 
       incoming.add([
         {
-          "jsonrpc": "2.0",
-          "method": "foo",
-          "params": {"bar": "baz"},
-          "id": 0
+          'jsonrpc': '2.0',
+          'method': 'foo',
+          'params': {'bar': 'baz'},
+          'id': 0
         },
         {
-          "jsonrpc": "2.0",
-          "method": "a",
-          "params": {"b": "c"},
-          "id": 1
+          'jsonrpc': '2.0',
+          'method': 'a',
+          'params': {'b': 'c'},
+          'id': 1
         },
         {
-          "jsonrpc": "2.0",
-          "method": "w",
-          "params": {"x": "y"},
-          "id": 2
+          'jsonrpc': '2.0',
+          'method': 'w',
+          'params': {'x': 'y'},
+          'id': 2
         }
       ]);
     });
 
-    test("returns a response for malformed JSON", () {
-      var incomingController = new StreamController<String>();
-      var outgoingController = new StreamController<String>();
-      var jsonPeer = new json_rpc.Peer(
-          new StreamChannel(incomingController.stream, outgoingController));
+    test('returns a response for malformed JSON', () {
+      var incomingController = StreamController<String>();
+      var outgoingController = StreamController<String>();
+      var jsonPeer = json_rpc.Peer(
+          StreamChannel(incomingController.stream, outgoingController));
 
       expect(
           outgoingController.stream.first.then(jsonDecode),
           completion({
-            "jsonrpc": "2.0",
-            "error": {
+            'jsonrpc': '2.0',
+            'error': {
               'code': error_code.PARSE_ERROR,
-              "message": startsWith("Invalid JSON: "),
+              'message': startsWith('Invalid JSON: '),
               // TODO(nweiz): Always expect the source when sdk#25655 is fixed.
-              "data": {
+              'data': {
                 'request': anyOf([isNull, '{invalid'])
               }
             },
-            "id": null
+            'id': null
           }));
 
       jsonPeer.listen();
 
-      incomingController.add("{invalid");
+      incomingController.add('{invalid');
     });
 
-    test("returns a response for incorrectly-structured JSON", () {
+    test('returns a response for incorrectly-structured JSON', () {
       expect(
           outgoing.first,
           completion({
-            "jsonrpc": "2.0",
-            "error": {
+            'jsonrpc': '2.0',
+            'error': {
               'code': error_code.INVALID_REQUEST,
-              "message": 'Request must contain a "jsonrpc" key.',
-              "data": {
+              'message': 'Request must contain a "jsonrpc" key.',
+              'data': {
                 'request': {'completely': 'wrong'}
               }
             },
-            "id": null
+            'id': null
           }));
 
       peer.listen();
 
-      incoming.add({"completely": "wrong"});
+      incoming.add({'completely': 'wrong'});
     });
   });
 
-  test("can notify on unhandled errors for if the method throws", () async {
-    Exception exception = Exception('test exception');
-    var incomingController = new StreamController();
-    var outgoingController = new StreamController();
-    final Completer<Exception> completer = Completer<Exception>();
-    peer = new json_rpc.Peer.withoutJson(
-      new StreamChannel(incomingController.stream, outgoingController),
+  test('can notify on unhandled errors for if the method throws', () async {
+    var exception = Exception('test exception');
+    var incomingController = StreamController();
+    var outgoingController = StreamController();
+    final completer = Completer<Exception>();
+    peer = json_rpc.Peer.withoutJson(
+      StreamChannel(incomingController.stream, outgoingController),
       onUnhandledError: (error, stack) {
         completer.complete(error);
       },
@@ -201,7 +201,7 @@
       ..listen();
 
     incomingController.add({'jsonrpc': '2.0', 'method': 'foo'});
-    Exception receivedException = await completer.future;
+    var receivedException = await completer.future;
     expect(receivedException, equals(exception));
   });
 }
diff --git a/test/server/batch_test.dart b/test/server/batch_test.dart
index 3257256..c9411b3 100644
--- a/test/server/batch_test.dart
+++ b/test/server/batch_test.dart
@@ -10,7 +10,7 @@
 void main() {
   var controller;
   setUp(() {
-    controller = new ServerController();
+    controller = ServerController();
     controller.server
       ..registerMethod('foo', () => 'foo')
       ..registerMethod('id', (params) => params.value)
diff --git a/test/server/invalid_request_test.dart b/test/server/invalid_request_test.dart
index e62558f..4dbca0c 100644
--- a/test/server/invalid_request_test.dart
+++ b/test/server/invalid_request_test.dart
@@ -9,19 +9,19 @@
 
 void main() {
   var controller;
-  setUp(() => controller = new ServerController());
+  setUp(() => controller = ServerController());
 
-  test("a non-Array/Object request is invalid", () {
+  test('a non-Array/Object request is invalid', () {
     expectErrorResponse(controller, 'foo', error_code.INVALID_REQUEST,
         'Request must be an Array or an Object.');
   });
 
-  test("requests must have a jsonrpc key", () {
+  test('requests must have a jsonrpc key', () {
     expectErrorResponse(controller, {'method': 'foo', 'id': 1234},
         error_code.INVALID_REQUEST, 'Request must contain a "jsonrpc" key.');
   });
 
-  test("the jsonrpc version must be 2.0", () {
+  test('the jsonrpc version must be 2.0', () {
     expectErrorResponse(
         controller,
         {'jsonrpc': '1.0', 'method': 'foo', 'id': 1234},
@@ -29,12 +29,12 @@
         'Invalid JSON-RPC version "1.0", expected "2.0".');
   });
 
-  test("requests must have a method key", () {
+  test('requests must have a method key', () {
     expectErrorResponse(controller, {'jsonrpc': '2.0', 'id': 1234},
         error_code.INVALID_REQUEST, 'Request must contain a "method" key.');
   });
 
-  test("request method must be a string", () {
+  test('request method must be a string', () {
     expectErrorResponse(
         controller,
         {'jsonrpc': '2.0', 'method': 1234, 'id': 1234},
@@ -42,7 +42,7 @@
         'Request method must be a string, but was 1234.');
   });
 
-  test("request params must be an Array or Object", () {
+  test('request params must be an Array or Object', () {
     expectErrorResponse(
         controller,
         {'jsonrpc': '2.0', 'method': 'foo', 'params': 1234, 'id': 1234},
@@ -50,7 +50,7 @@
         'Request params must be an Array or an Object, but was 1234.');
   });
 
-  test("request id may not be an Array or Object", () {
+  test('request id may not be an Array or Object', () {
     expect(
         controller.handleRequest({
           'jsonrpc': '2.0',
diff --git a/test/server/parameters_test.dart b/test/server/parameters_test.dart
index c970bef..8b8d07f 100644
--- a/test/server/parameters_test.dart
+++ b/test/server/parameters_test.dart
@@ -8,231 +8,231 @@
 import 'utils.dart';
 
 void main() {
-  group("with named parameters", () {
+  group('with named parameters', () {
     var parameters;
     setUp(() {
-      parameters = new json_rpc.Parameters("foo", {
-        "num": 1.5,
-        "int": 1,
-        "bool": true,
-        "string": "zap",
-        "list": [1, 2, 3],
-        "date-time": "1990-01-01 00:00:00.000",
-        "uri": "http://dartlang.org",
-        "invalid-uri": "http://[::1",
-        "map": {"num": 4.2, "bool": false}
+      parameters = json_rpc.Parameters('foo', {
+        'num': 1.5,
+        'int': 1,
+        'bool': true,
+        'string': 'zap',
+        'list': [1, 2, 3],
+        'date-time': '1990-01-01 00:00:00.000',
+        'uri': 'http://dartlang.org',
+        'invalid-uri': 'http://[::1',
+        'map': {'num': 4.2, 'bool': false}
       });
     });
 
-    test("value returns the wrapped value", () {
+    test('value returns the wrapped value', () {
       expect(
           parameters.value,
           equals({
-            "num": 1.5,
-            "int": 1,
-            "bool": true,
-            "string": "zap",
-            "list": [1, 2, 3],
-            "date-time": "1990-01-01 00:00:00.000",
-            "uri": "http://dartlang.org",
-            "invalid-uri": "http://[::1",
-            "map": {"num": 4.2, "bool": false}
+            'num': 1.5,
+            'int': 1,
+            'bool': true,
+            'string': 'zap',
+            'list': [1, 2, 3],
+            'date-time': '1990-01-01 00:00:00.000',
+            'uri': 'http://dartlang.org',
+            'invalid-uri': 'http://[::1',
+            'map': {'num': 4.2, 'bool': false}
           }));
     });
 
-    test("[int] throws a parameter error", () {
+    test('[int] throws a parameter error', () {
       expect(
           () => parameters[0],
           throwsInvalidParams('Parameters for method "foo" must be passed by '
               'position.'));
     });
 
-    test("[].value returns existing parameters", () {
+    test('[].value returns existing parameters', () {
       expect(parameters['num'].value, equals(1.5));
     });
 
-    test("[].valueOr returns existing parameters", () {
+    test('[].valueOr returns existing parameters', () {
       expect(parameters['num'].valueOr(7), equals(1.5));
     });
 
-    test("[].value fails for absent parameters", () {
+    test('[].value fails for absent parameters', () {
       expect(
           () => parameters['fblthp'].value,
           throwsInvalidParams('Request for method "foo" is missing required '
               'parameter "fblthp".'));
     });
 
-    test("[].valueOr succeeds for absent parameters", () {
+    test('[].valueOr succeeds for absent parameters', () {
       expect(parameters['fblthp'].valueOr(7), equals(7));
     });
 
-    test("[].exists returns true for existing parameters", () {
+    test('[].exists returns true for existing parameters', () {
       expect(parameters['num'].exists, isTrue);
     });
 
-    test("[].exists returns false for missing parameters", () {
+    test('[].exists returns false for missing parameters', () {
       expect(parameters['fblthp'].exists, isFalse);
     });
 
-    test("[].asNum returns numeric parameters", () {
+    test('[].asNum returns numeric parameters', () {
       expect(parameters['num'].asNum, equals(1.5));
       expect(parameters['int'].asNum, equals(1));
     });
 
-    test("[].asNumOr returns numeric parameters", () {
+    test('[].asNumOr returns numeric parameters', () {
       expect(parameters['num'].asNumOr(7), equals(1.5));
     });
 
-    test("[].asNum fails for non-numeric parameters", () {
+    test('[].asNum fails for non-numeric parameters', () {
       expect(
           () => parameters['bool'].asNum,
           throwsInvalidParams('Parameter "bool" for method "foo" must be a '
               'number, but was true.'));
     });
 
-    test("[].asNumOr fails for non-numeric parameters", () {
+    test('[].asNumOr fails for non-numeric parameters', () {
       expect(
           () => parameters['bool'].asNumOr(7),
           throwsInvalidParams('Parameter "bool" for method "foo" must be a '
               'number, but was true.'));
     });
 
-    test("[].asNum fails for absent parameters", () {
+    test('[].asNum fails for absent parameters', () {
       expect(
           () => parameters['fblthp'].asNum,
           throwsInvalidParams('Request for method "foo" is missing required '
               'parameter "fblthp".'));
     });
 
-    test("[].asNumOr succeeds for absent parameters", () {
+    test('[].asNumOr succeeds for absent parameters', () {
       expect(parameters['fblthp'].asNumOr(7), equals(7));
     });
 
-    test("[].asInt returns integer parameters", () {
+    test('[].asInt returns integer parameters', () {
       expect(parameters['int'].asInt, equals(1));
     });
 
-    test("[].asIntOr returns integer parameters", () {
+    test('[].asIntOr returns integer parameters', () {
       expect(parameters['int'].asIntOr(7), equals(1));
     });
 
-    test("[].asInt fails for non-integer parameters", () {
+    test('[].asInt fails for non-integer parameters', () {
       expect(
           () => parameters['bool'].asInt,
           throwsInvalidParams('Parameter "bool" for method "foo" must be an '
               'integer, but was true.'));
     });
 
-    test("[].asIntOr succeeds for absent parameters", () {
+    test('[].asIntOr succeeds for absent parameters', () {
       expect(parameters['fblthp'].asIntOr(7), equals(7));
     });
 
-    test("[].asBool returns boolean parameters", () {
+    test('[].asBool returns boolean parameters', () {
       expect(parameters['bool'].asBool, isTrue);
     });
 
-    test("[].asBoolOr returns boolean parameters", () {
+    test('[].asBoolOr returns boolean parameters', () {
       expect(parameters['bool'].asBoolOr(false), isTrue);
     });
 
-    test("[].asBoolOr fails for non-boolean parameters", () {
+    test('[].asBoolOr fails for non-boolean parameters', () {
       expect(
           () => parameters['int'].asBool,
           throwsInvalidParams('Parameter "int" for method "foo" must be a '
               'boolean, but was 1.'));
     });
 
-    test("[].asBoolOr succeeds for absent parameters", () {
+    test('[].asBoolOr succeeds for absent parameters', () {
       expect(parameters['fblthp'].asBoolOr(false), isFalse);
     });
 
-    test("[].asString returns string parameters", () {
-      expect(parameters['string'].asString, equals("zap"));
+    test('[].asString returns string parameters', () {
+      expect(parameters['string'].asString, equals('zap'));
     });
 
-    test("[].asStringOr returns string parameters", () {
-      expect(parameters['string'].asStringOr("bap"), equals("zap"));
+    test('[].asStringOr returns string parameters', () {
+      expect(parameters['string'].asStringOr('bap'), equals('zap'));
     });
 
-    test("[].asString fails for non-string parameters", () {
+    test('[].asString fails for non-string parameters', () {
       expect(
           () => parameters['int'].asString,
           throwsInvalidParams('Parameter "int" for method "foo" must be a '
               'string, but was 1.'));
     });
 
-    test("[].asStringOr succeeds for absent parameters", () {
-      expect(parameters['fblthp'].asStringOr("bap"), equals("bap"));
+    test('[].asStringOr succeeds for absent parameters', () {
+      expect(parameters['fblthp'].asStringOr('bap'), equals('bap'));
     });
 
-    test("[].asList returns list parameters", () {
+    test('[].asList returns list parameters', () {
       expect(parameters['list'].asList, equals([1, 2, 3]));
     });
 
-    test("[].asListOr returns list parameters", () {
+    test('[].asListOr returns list parameters', () {
       expect(parameters['list'].asListOr([5, 6, 7]), equals([1, 2, 3]));
     });
 
-    test("[].asList fails for non-list parameters", () {
+    test('[].asList fails for non-list parameters', () {
       expect(
           () => parameters['int'].asList,
           throwsInvalidParams('Parameter "int" for method "foo" must be an '
               'Array, but was 1.'));
     });
 
-    test("[].asListOr succeeds for absent parameters", () {
+    test('[].asListOr succeeds for absent parameters', () {
       expect(parameters['fblthp'].asListOr([5, 6, 7]), equals([5, 6, 7]));
     });
 
-    test("[].asMap returns map parameters", () {
-      expect(parameters['map'].asMap, equals({"num": 4.2, "bool": false}));
+    test('[].asMap returns map parameters', () {
+      expect(parameters['map'].asMap, equals({'num': 4.2, 'bool': false}));
     });
 
-    test("[].asMapOr returns map parameters", () {
+    test('[].asMapOr returns map parameters', () {
       expect(
-          parameters['map'].asMapOr({}), equals({"num": 4.2, "bool": false}));
+          parameters['map'].asMapOr({}), equals({'num': 4.2, 'bool': false}));
     });
 
-    test("[].asMap fails for non-map parameters", () {
+    test('[].asMap fails for non-map parameters', () {
       expect(
           () => parameters['int'].asMap,
           throwsInvalidParams('Parameter "int" for method "foo" must be an '
               'Object, but was 1.'));
     });
 
-    test("[].asMapOr succeeds for absent parameters", () {
+    test('[].asMapOr succeeds for absent parameters', () {
       expect(parameters['fblthp'].asMapOr({}), equals({}));
     });
 
-    test("[].asDateTime returns date/time parameters", () {
-      expect(parameters['date-time'].asDateTime, equals(new DateTime(1990)));
+    test('[].asDateTime returns date/time parameters', () {
+      expect(parameters['date-time'].asDateTime, equals(DateTime(1990)));
     });
 
-    test("[].asDateTimeOr returns date/time parameters", () {
-      expect(parameters['date-time'].asDateTimeOr(new DateTime(2014)),
-          equals(new DateTime(1990)));
+    test('[].asDateTimeOr returns date/time parameters', () {
+      expect(parameters['date-time'].asDateTimeOr(DateTime(2014)),
+          equals(DateTime(1990)));
     });
 
-    test("[].asDateTime fails for non-date/time parameters", () {
+    test('[].asDateTime fails for non-date/time parameters', () {
       expect(
           () => parameters['int'].asDateTime,
           throwsInvalidParams('Parameter "int" for method "foo" must be a '
               'string, but was 1.'));
     });
 
-    test("[].asDateTimeOr succeeds for absent parameters", () {
-      expect(parameters['fblthp'].asDateTimeOr(new DateTime(2014)),
-          equals(new DateTime(2014)));
+    test('[].asDateTimeOr succeeds for absent parameters', () {
+      expect(parameters['fblthp'].asDateTimeOr(DateTime(2014)),
+          equals(DateTime(2014)));
     });
 
-    test("[].asDateTime fails for non-date/time parameters", () {
+    test('[].asDateTime fails for non-date/time parameters', () {
       expect(
           () => parameters['int'].asDateTime,
           throwsInvalidParams('Parameter "int" for method "foo" must be a '
               'string, but was 1.'));
     });
 
-    test("[].asDateTime fails for invalid date/times", () {
+    test('[].asDateTime fails for invalid date/times', () {
       expect(
           () => parameters['string'].asDateTime,
           throwsInvalidParams('Parameter "string" for method "foo" must be a '
@@ -240,35 +240,35 @@
               'Invalid date format'));
     });
 
-    test("[].asUri returns URI parameters", () {
+    test('[].asUri returns URI parameters', () {
       expect(parameters['uri'].asUri, equals(Uri.parse('http://dartlang.org')));
     });
 
-    test("[].asUriOr returns URI parameters", () {
+    test('[].asUriOr returns URI parameters', () {
       expect(parameters['uri'].asUriOr(Uri.parse('http://google.com')),
           equals(Uri.parse('http://dartlang.org')));
     });
 
-    test("[].asUri fails for non-URI parameters", () {
+    test('[].asUri fails for non-URI parameters', () {
       expect(
           () => parameters['int'].asUri,
           throwsInvalidParams('Parameter "int" for method "foo" must be a '
               'string, but was 1.'));
     });
 
-    test("[].asUriOr succeeds for absent parameters", () {
+    test('[].asUriOr succeeds for absent parameters', () {
       expect(parameters['fblthp'].asUriOr(Uri.parse('http://google.com')),
           equals(Uri.parse('http://google.com')));
     });
 
-    test("[].asUri fails for non-URI parameters", () {
+    test('[].asUri fails for non-URI parameters', () {
       expect(
           () => parameters['int'].asUri,
           throwsInvalidParams('Parameter "int" for method "foo" must be a '
               'string, but was 1.'));
     });
 
-    test("[].asUri fails for invalid URIs", () {
+    test('[].asUri fails for invalid URIs', () {
       expect(
           () => parameters['invalid-uri'].asUri,
           throwsInvalidParams('Parameter "invalid-uri" for method "foo" must '
@@ -276,34 +276,34 @@
               'Missing end `]` to match `[` in host'));
     });
 
-    group("with a nested parameter map", () {
+    group('with a nested parameter map', () {
       var nested;
       setUp(() => nested = parameters['map']);
 
-      test("[int] fails with a type error", () {
+      test('[int] fails with a type error', () {
         expect(
             () => nested[0],
             throwsInvalidParams('Parameter "map" for method "foo" must be an '
                 'Array, but was {"num":4.2,"bool":false}.'));
       });
 
-      test("[].value returns existing parameters", () {
+      test('[].value returns existing parameters', () {
         expect(nested['num'].value, equals(4.2));
         expect(nested['bool'].value, isFalse);
       });
 
-      test("[].value fails for absent parameters", () {
+      test('[].value fails for absent parameters', () {
         expect(
             () => nested['fblthp'].value,
             throwsInvalidParams('Request for method "foo" is missing required '
                 'parameter map.fblthp.'));
       });
 
-      test("typed getters return correctly-typed parameters", () {
+      test('typed getters return correctly-typed parameters', () {
         expect(nested['num'].asNum, equals(4.2));
       });
 
-      test("typed getters fail for incorrectly-typed parameters", () {
+      test('typed getters fail for incorrectly-typed parameters', () {
         expect(
             () => nested['bool'].asNum,
             throwsInvalidParams('Parameter map.bool for method "foo" must be '
@@ -311,34 +311,34 @@
       });
     });
 
-    group("with a nested parameter list", () {
+    group('with a nested parameter list', () {
       var nested;
       setUp(() => nested = parameters['list']);
 
-      test("[string] fails with a type error", () {
+      test('[string] fails with a type error', () {
         expect(
             () => nested['foo'],
             throwsInvalidParams('Parameter "list" for method "foo" must be an '
                 'Object, but was [1,2,3].'));
       });
 
-      test("[].value returns existing parameters", () {
+      test('[].value returns existing parameters', () {
         expect(nested[0].value, equals(1));
         expect(nested[1].value, equals(2));
       });
 
-      test("[].value fails for absent parameters", () {
+      test('[].value fails for absent parameters', () {
         expect(
             () => nested[5].value,
             throwsInvalidParams('Request for method "foo" is missing required '
                 'parameter list[5].'));
       });
 
-      test("typed getters return correctly-typed parameters", () {
+      test('typed getters return correctly-typed parameters', () {
         expect(nested[0].asInt, equals(1));
       });
 
-      test("typed getters fail for incorrectly-typed parameters", () {
+      test('typed getters fail for incorrectly-typed parameters', () {
         expect(
             () => nested[0].asBool,
             throwsInvalidParams('Parameter list[0] for method "foo" must be '
@@ -347,43 +347,43 @@
     });
   });
 
-  group("with positional parameters", () {
+  group('with positional parameters', () {
     var parameters;
-    setUp(() => parameters = new json_rpc.Parameters("foo", [1, 2, 3, 4, 5]));
+    setUp(() => parameters = json_rpc.Parameters('foo', [1, 2, 3, 4, 5]));
 
-    test("value returns the wrapped value", () {
+    test('value returns the wrapped value', () {
       expect(parameters.value, equals([1, 2, 3, 4, 5]));
     });
 
-    test("[string] throws a parameter error", () {
+    test('[string] throws a parameter error', () {
       expect(
           () => parameters['foo'],
           throwsInvalidParams('Parameters for method "foo" must be passed by '
               'name.'));
     });
 
-    test("[].value returns existing parameters", () {
+    test('[].value returns existing parameters', () {
       expect(parameters[2].value, equals(3));
     });
 
-    test("[].value fails for out-of-range parameters", () {
+    test('[].value fails for out-of-range parameters', () {
       expect(
           () => parameters[10].value,
           throwsInvalidParams('Request for method "foo" is missing required '
               'parameter 11.'));
     });
 
-    test("[].exists returns true for existing parameters", () {
+    test('[].exists returns true for existing parameters', () {
       expect(parameters[0].exists, isTrue);
     });
 
-    test("[].exists returns false for missing parameters", () {
+    test('[].exists returns false for missing parameters', () {
       expect(parameters[10].exists, isFalse);
     });
   });
 
-  test("with a complex parameter path", () {
-    var parameters = new json_rpc.Parameters("foo", {
+  test('with a complex parameter path', () {
+    var parameters = json_rpc.Parameters('foo', {
       'bar baz': [
         0,
         1,
diff --git a/test/server/server_test.dart b/test/server/server_test.dart
index b9ba504..14ae1e4 100644
--- a/test/server/server_test.dart
+++ b/test/server/server_test.dart
@@ -12,9 +12,9 @@
 
 void main() {
   var controller;
-  setUp(() => controller = new ServerController());
+  setUp(() => controller = ServerController());
 
-  test("calls a registered method with the given name", () {
+  test('calls a registered method with the given name', () {
     controller.server.registerMethod('foo', (params) {
       return {'params': params.value};
     });
@@ -35,7 +35,7 @@
         })));
   });
 
-  test("calls a method that takes no parameters", () {
+  test('calls a method that takes no parameters', () {
     controller.server.registerMethod('foo', () => 'foo');
 
     expect(
@@ -44,7 +44,7 @@
         completion(equals({'jsonrpc': '2.0', 'result': 'foo', 'id': 1234})));
   });
 
-  test("a method that takes no parameters rejects parameters", () {
+  test('a method that takes no parameters rejects parameters', () {
     controller.server.registerMethod('foo', () => 'foo');
 
     expectErrorResponse(
@@ -54,9 +54,9 @@
         'No parameters are allowed for method "foo".');
   });
 
-  test("an unexpected error in a method is captured", () {
+  test('an unexpected error in a method is captured', () {
     controller.server
-        .registerMethod('foo', () => throw new FormatException('bad format'));
+        .registerMethod('foo', () => throw FormatException('bad format'));
 
     expect(
         controller
@@ -70,13 +70,13 @@
             'data': {
               'request': {'jsonrpc': '2.0', 'method': 'foo', 'id': 1234},
               'full': 'FormatException: bad format',
-              'stack': new TypeMatcher<String>()
+              'stack': TypeMatcher<String>()
             }
           }
         }));
   });
 
-  test("doesn't return a result for a notification", () {
+  test('doesn\'t return a result for a notification', () {
     controller.server.registerMethod('foo', (args) => 'result');
 
     expect(
@@ -85,9 +85,9 @@
         doesNotComplete);
   });
 
-  test("includes the error data in the response", () {
+  test('includes the error data in the response', () {
     controller.server.registerMethod('foo', (params) {
-      throw new json_rpc.RpcException(5, 'Error message.', data: 'data value');
+      throw json_rpc.RpcException(5, 'Error message.', data: 'data value');
     });
 
     expectErrorResponse(
@@ -98,13 +98,13 @@
         data: 'data value');
   });
 
-  test("a JSON parse error is rejected", () {
+  test('a JSON parse error is rejected', () {
     return controller.handleJsonRequest('invalid json {').then((result) {
       expect(jsonDecode(result), {
         'jsonrpc': '2.0',
         'error': {
           'code': error_code.PARSE_ERROR,
-          'message': startsWith("Invalid JSON: "),
+          'message': startsWith('Invalid JSON: '),
           // TODO(nweiz): Always expect the source when sdk#25655 is fixed.
           'data': {
             'request': anyOf([isNull, 'invalid json {'])
@@ -115,8 +115,8 @@
     });
   });
 
-  group("fallbacks", () {
-    test("calls a fallback if no method matches", () {
+  group('fallbacks', () {
+    test('calls a fallback if no method matches', () {
       controller.server
         ..registerMethod('foo', () => 'foo')
         ..registerMethod('bar', () => 'foo')
@@ -138,10 +138,10 @@
           })));
     });
 
-    test("calls the first matching fallback", () {
+    test('calls the first matching fallback', () {
       controller.server
         ..registerFallback((params) =>
-            throw new json_rpc.RpcException.methodNotFound(params.method))
+            throw json_rpc.RpcException.methodNotFound(params.method))
         ..registerFallback((params) => 'fallback 2')
         ..registerFallback((params) => 'fallback 3');
 
@@ -152,9 +152,9 @@
               equals({'jsonrpc': '2.0', 'result': 'fallback 2', 'id': 1234})));
     });
 
-    test("an unexpected error in a fallback is captured", () {
+    test('an unexpected error in a fallback is captured', () {
       controller.server
-          .registerFallback((_) => throw new FormatException('bad format'));
+          .registerFallback((_) => throw FormatException('bad format'));
 
       expect(
           controller
@@ -168,14 +168,14 @@
               'data': {
                 'request': {'jsonrpc': '2.0', 'method': 'foo', 'id': 1234},
                 'full': 'FormatException: bad format',
-                'stack': new TypeMatcher<String>()
+                'stack': TypeMatcher<String>()
               }
             }
           }));
     });
   });
 
-  test("disallows multiple methods with the same name", () {
+  test('disallows multiple methods with the same name', () {
     controller.server.registerMethod('foo', () => null);
     expect(() => controller.server.registerMethod('foo', () => null),
         throwsArgumentError);
diff --git a/test/server/stream_test.dart b/test/server/stream_test.dart
index 19629e7..7105cd6 100644
--- a/test/server/stream_test.dart
+++ b/test/server/stream_test.dart
@@ -14,13 +14,13 @@
   var responseController;
   var server;
   setUp(() {
-    requestController = new StreamController();
-    responseController = new StreamController();
-    server = new json_rpc.Server.withoutJson(
-        new StreamChannel(requestController.stream, responseController.sink));
+    requestController = StreamController();
+    responseController = StreamController();
+    server = json_rpc.Server.withoutJson(
+        StreamChannel(requestController.stream, responseController.sink));
   });
 
-  test(".withoutJson supports decoded stream and sink", () {
+  test('.withoutJson supports decoded stream and sink', () {
     server.listen();
 
     server.registerMethod('foo', (params) {
@@ -45,7 +45,7 @@
         })));
   });
 
-  test(".listen returns when the controller is closed", () {
+  test('.listen returns when the controller is closed', () {
     var hasListenCompeted = false;
     expect(server.listen().then((_) => hasListenCompeted = true), completes);
 
@@ -57,18 +57,18 @@
     });
   });
 
-  test(".listen returns a stream error", () {
+  test('.listen returns a stream error', () {
     expect(server.listen(), throwsA('oh no'));
     requestController.addError('oh no');
   });
 
-  test(".listen can't be called twice", () {
+  test('.listen can\'t be called twice', () {
     server.listen();
 
     expect(() => server.listen(), throwsStateError);
   });
 
-  test(".close cancels the stream subscription and closes the sink", () {
+  test('.close cancels the stream subscription and closes the sink', () {
     // Work around sdk#19095.
     responseController.stream.listen(null);
 
diff --git a/test/server/utils.dart b/test/server/utils.dart
index ef089ad..bf1db6f 100644
--- a/test/server/utils.dart
+++ b/test/server/utils.dart
@@ -14,18 +14,18 @@
 /// A controller used to test a [json_rpc.Server].
 class ServerController {
   /// The controller for the server's request stream.
-  final _requestController = new StreamController<String>();
+  final _requestController = StreamController<String>();
 
   /// The controller for the server's response sink.
-  final _responseController = new StreamController<String>();
+  final _responseController = StreamController<String>();
 
   /// The server.
   json_rpc.Server get server => _server;
   json_rpc.Server _server;
 
   ServerController({json_rpc.ErrorCallback onUnhandledError}) {
-    _server = new json_rpc.Server(
-        new StreamChannel(_requestController.stream, _responseController.sink),
+    _server = json_rpc.Server(
+        StreamChannel(_requestController.stream, _responseController.sink),
         onUnhandledError: onUnhandledError);
     _server.listen();
   }
@@ -50,7 +50,7 @@
     {data}) {
   var id;
   if (request is Map) id = request['id'];
-  if (data == null) data = {'request': request};
+  data ??= {'request': request};
 
   expect(
       controller.handleRequest(request),
@@ -65,7 +65,7 @@
 /// `invalid_params` error code.
 Matcher throwsInvalidParams(String message) {
   return throwsA(predicate((error) {
-    expect(error, new TypeMatcher<json_rpc.RpcException>());
+    expect(error, TypeMatcher<json_rpc.RpcException>());
     expect(error.code, equals(error_code.INVALID_PARAMS));
     expect(error.message, equals(message));
     return true;