diff --git a/analysis_options.yaml b/analysis_options.yaml
index 2e6cdca..2343b57 100644
--- a/analysis_options.yaml
+++ b/analysis_options.yaml
@@ -1 +1,4 @@
-analyzer:
+linter:
+  rules:
+    - unnecessary_new
+    - unnecessary_const
diff --git a/lib/src/current_isolate_resolver.dart b/lib/src/current_isolate_resolver.dart
index 1244b5c..e3b9770 100644
--- a/lib/src/current_isolate_resolver.dart
+++ b/lib/src/current_isolate_resolver.dart
@@ -34,7 +34,7 @@
 
   Future<SyncPackageResolver> get asSync async {
     var root = await packageRoot;
-    if (root != null) return new PackageRootResolver(root);
+    if (root != null) return PackageRootResolver(root);
 
     var map = await packageConfigMap;
 
@@ -43,7 +43,7 @@
     // to handle that case so we do.
     if (map == null) return SyncPackageResolver.none;
 
-    return new PackageConfigResolver(map, uri: await packageConfigUri);
+    return PackageConfigResolver(map, uri: await packageConfigUri);
   }
 
   Future<String> get processArgument async {
@@ -66,7 +66,7 @@
 
   Future<String> packagePath(String package) async {
     var root = await packageRoot;
-    if (root != null) return new PackageRootResolver(root).packagePath(package);
+    if (root != null) return PackageRootResolver(root).packagePath(package);
 
     return p.dirname(p.fromUri(await urlFor(package)));
   }
diff --git a/lib/src/no_package_resolver.dart b/lib/src/no_package_resolver.dart
index 9d324d4..50ea132 100644
--- a/lib/src/no_package_resolver.dart
+++ b/lib/src/no_package_resolver.dart
@@ -14,7 +14,7 @@
   Uri get packageRoot => null;
   String get processArgument => null;
 
-  PackageResolver get asAsync => new AsyncPackageResolver(this);
+  PackageResolver get asAsync => AsyncPackageResolver(this);
 
   Uri resolveUri(packageUri) {
     // Verify that the URI is valid.
diff --git a/lib/src/package_config_resolver.dart b/lib/src/package_config_resolver.dart
index c2078bd..9d56b2e 100644
--- a/lib/src/package_config_resolver.dart
+++ b/lib/src/package_config_resolver.dart
@@ -22,16 +22,17 @@
   Uri get packageConfigUri {
     if (_uri != null) return _uri;
 
-    var buffer = new StringBuffer();
+    var buffer = StringBuffer();
     packages_file.write(buffer, packageConfigMap, comment: "");
-    _uri = new UriData.fromString(buffer.toString(),
-        parameters: {"charset": "utf-8"}).uri;
+    _uri =
+        UriData.fromString(buffer.toString(), parameters: {"charset": "utf-8"})
+            .uri;
     return _uri;
   }
 
   Uri _uri;
 
-  PackageResolver get asAsync => new AsyncPackageResolver(this);
+  PackageResolver get asAsync => AsyncPackageResolver(this);
 
   String get processArgument => "--packages=$packageConfigUri";
 
@@ -42,7 +43,7 @@
   /// Normalizes the URIs in [map] to ensure that they all end in a trailing
   /// slash.
   static Map<String, Uri> _normalizeMap(Map<String, Uri> map) =>
-      new UnmodifiableMapView(
+      UnmodifiableMapView(
           mapMap(map, value: (_, uri) => ensureTrailingSlash(uri)));
 
   Uri resolveUri(packageUri) {
diff --git a/lib/src/package_resolver.dart b/lib/src/package_resolver.dart
index d53d761..3c4ed08 100644
--- a/lib/src/package_resolver.dart
+++ b/lib/src/package_resolver.dart
@@ -112,12 +112,12 @@
   /// fully-resolved. That is, any relative URIs in the original package config
   /// source should be resolved relative to its location.
   factory PackageResolver.config(Map<String, Uri> packageConfigMap, {uri}) =>
-      new PackageConfigResolver(packageConfigMap, uri: uri).asAsync;
+      PackageConfigResolver(packageConfigMap, uri: uri).asAsync;
 
   /// Returns the package resolution strategy for the given [packageRoot], which
   /// may be a [String] or a [Uri].
   factory PackageResolver.root(packageRoot) =>
-      new PackageRootResolver(packageRoot).asAsync;
+      PackageRootResolver(packageRoot).asAsync;
 
   /// Resolves [packageUri] according to this package resolution strategy.
   ///
diff --git a/lib/src/package_root_resolver.dart b/lib/src/package_root_resolver.dart
index 4774a34..c0e96c7 100644
--- a/lib/src/package_root_resolver.dart
+++ b/lib/src/package_root_resolver.dart
@@ -16,7 +16,7 @@
 
   final Uri packageRoot;
 
-  PackageResolver get asAsync => new AsyncPackageResolver(this);
+  PackageResolver get asAsync => AsyncPackageResolver(this);
 
   String get processArgument => "--package-root=$packageRoot";
 
diff --git a/lib/src/sync_package_resolver.dart b/lib/src/sync_package_resolver.dart
index 5cb4c99..1b7b47e 100644
--- a/lib/src/sync_package_resolver.dart
+++ b/lib/src/sync_package_resolver.dart
@@ -87,7 +87,7 @@
 
   /// Returns a package resolution strategy that is unable to resolve any
   /// `package:` URIs.
-  static final SyncPackageResolver none = new NoPackageResolver();
+  static final SyncPackageResolver none = NoPackageResolver();
 
   /// Loads a package config file from [uri] and returns its package resolution
   /// strategy.
@@ -101,8 +101,7 @@
   static Future<SyncPackageResolver> loadConfig(uri,
       {http.Client client}) async {
     uri = asUri(uri, "uri");
-    return new SyncPackageResolver.config(
-        await loadConfigMap(uri, client: client),
+    return SyncPackageResolver.config(await loadConfigMap(uri, client: client),
         uri: uri);
   }
 
diff --git a/lib/src/utils.dart b/lib/src/utils.dart
index b588c54..1609d56 100644
--- a/lib/src/utils.dart
+++ b/lib/src/utils.dart
@@ -34,7 +34,7 @@
   } else if (resolved.scheme == 'package') {
     return loadConfigMap(await isolate.resolvePackageUri(uri), client: client);
   } else {
-    throw new UnsupportedError(
+    throw UnsupportedError(
         'PackageInfo.loadConfig doesn\'t support URI scheme "${uri.scheme}:".');
   }
 
@@ -52,10 +52,10 @@
   uri = asUri(uri, name);
 
   if (uri.scheme != 'package') {
-    throw new FormatException(
+    throw FormatException(
         "Can only resolve a package: URI.", uri.toString(), 0);
   } else if (uri.pathSegments.isEmpty) {
-    throw new FormatException(
+    throw FormatException(
         "Expected package name.", uri.toString(), "package:".length);
   }
 
@@ -70,7 +70,7 @@
   if (uri is Uri) return uri;
   if (uri is String) return Uri.parse(uri);
 
-  throw new ArgumentError.value(uri, name, "Must be a String or a Uri.");
+  throw ArgumentError.value(uri, name, "Must be a String or a Uri.");
 }
 
 /// Returns a copy of [uri] with a trailing slash.
diff --git a/lib/src/utils_io.dart b/lib/src/utils_io.dart
index df768e6..65a9634 100644
--- a/lib/src/utils_io.dart
+++ b/lib/src/utils_io.dart
@@ -8,14 +8,14 @@
 
 Future<String> readFileAsString(Uri uri) {
   var path = uri.toFilePath(windows: Platform.isWindows);
-  return new File(path).readAsString();
+  return File(path).readAsString();
 }
 
 String packagePathForRoot(String package, Uri root) {
   if (root.scheme != 'file') return null;
 
   var libLink = p.join(p.fromUri(root), package);
-  if (!new Link(libLink).existsSync()) return null;
+  if (!Link(libLink).existsSync()) return null;
 
-  return p.dirname(new Link(libLink).resolveSymbolicLinksSync());
+  return p.dirname(Link(libLink).resolveSymbolicLinksSync());
 }
diff --git a/pubspec.yaml b/pubspec.yaml
index 344aac8..44d86ec 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: package_resolver
-version: 1.0.10
+version: 1.0.11-dev
 
 description: First-class package resolution strategy classes.
 author: Dart Team <misc@dartlang.org>
diff --git a/test/current_isolate_info_test.dart b/test/current_isolate_info_test.dart
index 8f87c21..4377ef8 100644
--- a/test/current_isolate_info_test.dart
+++ b/test/current_isolate_info_test.dart
@@ -19,13 +19,13 @@
   // PackageConfig.current.
   test("_packageResolverLibUri is correct", () async {
     var libPath = p.fromUri(await _packageResolverLibUri);
-    expect(new File(p.join(libPath, 'package_resolver.dart')).exists(),
+    expect(File(p.join(libPath, 'package_resolver.dart')).exists(),
         completion(isTrue));
   });
 
   test("_pathLibUri is correct", () async {
     var libPath = p.fromUri(await _pathLibUri);
-    expect(new File(p.join(libPath, 'path.dart')).exists(), completion(isTrue));
+    expect(File(p.join(libPath, 'path.dart')).exists(), completion(isTrue));
   });
 
   group("with a package config", () {
@@ -34,13 +34,13 @@
       var map;
       var currentIsolateMap = await PackageResolver.current.packageConfigMap;
       if (currentIsolateMap != null) {
-        map = new Map.of(currentIsolateMap);
+        map = Map.of(currentIsolateMap);
       } else {
         // If the isolate running this test isn't using package config, create
         // one from scratch with the same resolution semantics.
         map = {};
         var root = p.fromUri(await PackageResolver.current.packageRoot);
-        await for (var link in new Directory(root).list(followLinks: false)) {
+        await for (var link in Directory(root).list(followLinks: false)) {
           assert(link is Link);
           map[p.basename(link.path)] =
               ensureTrailingSlash(p.toUri((await link.resolveSymbolicLinks())));
@@ -53,7 +53,7 @@
       map["path"] = Uri.parse(p.url.normalize(map["path"].toString()));
       expect(map["path"].path, isNot(endsWith("/")));
 
-      resolver = new PackageResolver.config(map);
+      resolver = PackageResolver.config(map);
     });
 
     test("exposes the config map", () async {
@@ -199,12 +199,12 @@
   // If we're using a package root, we resolve the symlinks in the test code so
   // we need to resolve them here as well to ensure we're testing against the
   // same values.
-  var resolved = new Directory(p.fromUri(uri)).resolveSymbolicLinksSync();
+  var resolved = Directory(p.fromUri(uri)).resolveSymbolicLinksSync();
   return ensureTrailingSlash(p.toUri(resolved)).toString();
 }
 
 Future _spawn(String expression, PackageResolver packageResolver) async {
-  var data = new UriData.fromString(
+  var data = UriData.fromString(
       """
     import 'dart:convert';
     import 'dart:isolate';
@@ -218,8 +218,8 @@
       mimeType: "application/dart",
       parameters: {"charset": "utf-8"});
 
-  var receivePort = new ReceivePort();
-  var errorPort = new ReceivePort();
+  var receivePort = ReceivePort();
+  var errorPort = ReceivePort();
   try {
     var isolate = await Isolate.spawnUri(data.uri, [], receivePort.sendPort,
         // ignore: deprecated_member_use
@@ -230,7 +230,7 @@
     isolate.addErrorListener(errorPort.sendPort);
     errorPort.listen((message) {
       registerException(
-          message[0], message[1] == null ? null : new Trace.parse(message[1]));
+          message[0], message[1] == null ? null : Trace.parse(message[1]));
       errorPort.close();
       receivePort.close();
     });
diff --git a/test/package_config_info_test.dart b/test/package_config_info_test.dart
index 83c6e54..a4a1c12 100644
--- a/test/package_config_info_test.dart
+++ b/test/package_config_info_test.dart
@@ -14,7 +14,7 @@
 void main() {
   SyncPackageResolver resolver;
   setUp(() {
-    resolver = new SyncPackageResolver.config({
+    resolver = SyncPackageResolver.config({
       "foo": Uri.parse("file:///foo/bar/"),
       "bar": Uri.parse("http://dartlang.org/bar")
     }, uri: "file:///myapp/.packages");
@@ -22,15 +22,15 @@
 
   group("constructor", () {
     test("with a URI object", () {
-      var resolver = new SyncPackageResolver.config({},
+      var resolver = SyncPackageResolver.config({},
           uri: Uri.parse("file:///myapp/.packages"));
       expect(resolver.packageConfigUri,
           equals(Uri.parse("file:///myapp/.packages")));
     });
 
     test("with an invalid URI type", () {
-      expect(() => new SyncPackageResolver.config({}, uri: 12),
-          throwsArgumentError);
+      expect(
+          () => SyncPackageResolver.config({}, uri: 12), throwsArgumentError);
     });
   });
 
@@ -49,7 +49,7 @@
   });
 
   test("exposes a data: config URI if none is passed", () {
-    resolver = new SyncPackageResolver.config(resolver.packageConfigMap);
+    resolver = SyncPackageResolver.config(resolver.packageConfigMap);
     expect(
         resolver.packageConfigUri,
         equals(Uri.parse("data:;charset=utf-8,"
@@ -152,7 +152,7 @@
 
   group("packagePath", () {
     setUp(() {
-      resolver = new SyncPackageResolver.config({
+      resolver = SyncPackageResolver.config({
         "foo": p.toUri(p.join(p.current, 'lib')),
         "bar": Uri.parse("http://dartlang.org/bar")
       });
@@ -181,12 +181,12 @@
 
     tearDown(() async {
       if (server != null) await server.close();
-      await new Directory(sandbox).delete(recursive: true);
+      await Directory(sandbox).delete(recursive: true);
     });
 
     test("with an http: URI", () async {
       server = await shelf_io.serve((request) {
-        return new shelf.Response.ok("foo:file:///foo/bar/\n"
+        return shelf.Response.ok("foo:file:///foo/bar/\n"
             "bar:http://dartlang.org/bar/");
       }, 'localhost', 0);
 
@@ -205,7 +205,7 @@
 
     test("with a file: URI", () async {
       var packagesPath = p.join(sandbox, ".packages");
-      new File(packagesPath).writeAsStringSync("foo:file:///foo/bar/\n"
+      File(packagesPath).writeAsStringSync("foo:file:///foo/bar/\n"
           "bar:http://dartlang.org/bar/");
 
       var resolver =
diff --git a/test/package_root_info_test.dart b/test/package_root_info_test.dart
index 644d5a3..200d6e5 100644
--- a/test/package_root_info_test.dart
+++ b/test/package_root_info_test.dart
@@ -12,24 +12,23 @@
 void main() {
   var resolver;
   setUp(() {
-    resolver = new SyncPackageResolver.root("file:///foo/bar");
+    resolver = SyncPackageResolver.root("file:///foo/bar");
   });
 
   group("constructor", () {
     test("with a URI object", () {
-      var resolver =
-          new SyncPackageResolver.root(Uri.parse("file:///foo/bar/"));
+      var resolver = SyncPackageResolver.root(Uri.parse("file:///foo/bar/"));
       expect(resolver.packageRoot, equals(Uri.parse("file:///foo/bar/")));
     });
 
     test("with a URI without a path component", () {
       var resolver =
-          new SyncPackageResolver.root(Uri.parse("http://localhost:1234"));
+          SyncPackageResolver.root(Uri.parse("http://localhost:1234"));
       expect(resolver.packageRoot, equals(Uri.parse("http://localhost:1234/")));
     });
 
     test("with an invalid URI type", () {
-      expect(() => new SyncPackageResolver.root(12), throwsArgumentError);
+      expect(() => SyncPackageResolver.root(12), throwsArgumentError);
     });
   });
 
@@ -125,31 +124,29 @@
     });
 
     tearDown(() async {
-      await new Directory(sandbox).delete(recursive: true);
+      await Directory(sandbox).delete(recursive: true);
     });
 
     test("with a file: scheme", () async {
       var packageLib = p.join(sandbox, "foo/lib");
-      await new Directory(packageLib).create(recursive: true);
+      await Directory(packageLib).create(recursive: true);
 
       var packagesDir = p.join(sandbox, "packages");
       var fooLink = p.join(packagesDir, "foo");
-      await new Link(fooLink).create(packageLib, recursive: true);
+      await Link(fooLink).create(packageLib, recursive: true);
 
       var packagesLink = p.join(sandbox, "foo/packages");
-      await new Link(packagesLink).create(packagesDir);
+      await Link(packagesLink).create(packagesDir);
 
-      var resolver = new SyncPackageResolver.root(p.toUri(packagesLink));
+      var resolver = SyncPackageResolver.root(p.toUri(packagesLink));
 
-      expect(
-          resolver.packagePath("foo"),
-          equals(new Directory(p.join(sandbox, "foo"))
-              .resolveSymbolicLinksSync()));
+      expect(resolver.packagePath("foo"),
+          equals(Directory(p.join(sandbox, "foo")).resolveSymbolicLinksSync()));
       expect(resolver.packagePath("bar"), isNull);
     });
 
     test("without a file: scheme", () {
-      var resolver = new SyncPackageResolver.root("http://dartlang.org/bar");
+      var resolver = SyncPackageResolver.root("http://dartlang.org/bar");
       expect(resolver.packagePath("foo"), isNull);
     });
   }, testOn: "vm");