diff --git a/.travis.yml b/.travis.yml
index 63f5e5e..140ce59 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,16 +2,17 @@
 
 dart:
   - dev
-  - stable
 
 dart_task:
   - test
-  - dartanalyzer
 
 matrix:
   include:
     - dart: dev
       dart_task: dartfmt
+  include:
+    - dart: dev
+      dart_task: dartanalyzer
 
 # Only building master means that we don't run two builds for each pull request.
 branches:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e23e380..61e1788 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+## 1.6.0
+
+* Add a `PathMap` class that uses path equality for its keys.
+
+* Add a `PathSet` class that uses path equality for its contents.
+
 ## 1.5.1
 
 * Fix a number of bugs that occurred when the current working directory was `/`
diff --git a/lib/path.dart b/lib/path.dart
index 9885859..ed70f9d 100644
--- a/lib/path.dart
+++ b/lib/path.dart
@@ -49,6 +49,8 @@
 
 export 'src/context.dart' hide createInternal;
 export 'src/path_exception.dart';
+export 'src/path_map.dart';
+export 'src/path_set.dart';
 export 'src/style.dart';
 
 /// A default context for manipulating POSIX paths.
diff --git a/lib/src/path_map.dart b/lib/src/path_map.dart
new file mode 100644
index 0000000..53205ad
--- /dev/null
+++ b/lib/src/path_map.dart
@@ -0,0 +1,38 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:collection';
+
+import '../path.dart' as p;
+
+/// A map whose keys are paths, compared using [equals] and [hash].
+class PathMap<V> extends MapView<String, V> {
+  /// Creates an empty [PathMap] whose keys are compared using `context.equals`
+  /// and `context.hash`.
+  ///
+  /// The [context] defaults to the current path context.
+  PathMap({p.Context context}) : super(_create(context));
+
+  /// Creates a [PathMap] with the same keys and values as [other] whose keys
+  /// are compared using `context.equals` and `context.hash`.
+  ///
+  /// The [context] defaults to the current path context. If multiple keys in
+  /// [other] represent the same logical path, the last key's value will be
+  /// used.
+  PathMap.of(Map<String, V> other, {p.Context context})
+      : super(_create(context)..addAll(other));
+
+  /// Creates a map that uses [context] for equality and hashing.
+  static Map<String, V> _create<V>(p.Context context) {
+    context ??= p.context;
+    return new LinkedHashMap(
+        equals: (path1, path2) {
+          if (path1 == null) return path2 == null;
+          if (path2 == null) return false;
+          return context.equals(path1, path2);
+        },
+        hashCode: (path) => path == null ? 0 : context.hash(path),
+        isValidKey: (path) => path is String || path == null);
+  }
+}
diff --git a/lib/src/path_set.dart b/lib/src/path_set.dart
new file mode 100644
index 0000000..98f08a9
--- /dev/null
+++ b/lib/src/path_set.dart
@@ -0,0 +1,83 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:collection';
+
+import '../path.dart' as p;
+
+/// A set containing paths, compared using [equals] and [hash].
+class PathSet extends IterableBase<String> implements Set<String> {
+  /// The set to which we forward implementation methods.
+  final Set<String> _inner;
+
+  /// Creates an empty [PathSet] whose contents are compared using
+  /// `context.equals` and `context.hash`.
+  ///
+  /// The [context] defaults to the current path context.
+  PathSet({p.Context context}) : _inner = _create(context);
+
+  /// Creates a [PathSet] with the same contents as [other] whose elements are
+  /// compared using `context.equals` and `context.hash`.
+  ///
+  /// The [context] defaults to the current path context. If multiple elements
+  /// in [other] represent the same logical path, the first value will be
+  /// used.
+  PathSet.of(Iterable<String> other, {p.Context context})
+      : _inner = _create(context)..addAll(other);
+
+  /// Creates a set that uses [context] for equality and hashing.
+  static Set<String> _create(p.Context context) {
+    context ??= p.context;
+    return new LinkedHashSet(
+        equals: (path1, path2) {
+          if (path1 == null) return path2 == null;
+          if (path2 == null) return false;
+          return context.equals(path1, path2);
+        },
+        hashCode: (path) => path == null ? 0 : context.hash(path),
+        isValidKey: (path) => path is String || path == null);
+  }
+
+  // Normally we'd use DelegatingSetView from the collection package to
+  // implement these, but we want to avoid adding dependencies from path because
+  // it's so widely used that even brief version skew can be very painful.
+
+  Iterator<String> get iterator => _inner.iterator;
+
+  int get length => _inner.length;
+
+  bool add(String value) => _inner.add(value);
+
+  void addAll(Iterable<String> elements) => _inner.addAll(elements);
+
+  Set<T> cast<T>() => _inner.cast<T>();
+
+  void clear() => _inner.clear();
+
+  bool contains(Object other) => _inner.contains(other);
+
+  bool containsAll(Iterable<Object> other) => _inner.containsAll(other);
+
+  Set<String> difference(Set<Object> other) => _inner.difference(other);
+
+  Set<String> intersection(Set<Object> other) => _inner.intersection(other);
+
+  String lookup(Object element) => _inner.lookup(element);
+
+  bool remove(Object value) => _inner.remove(value);
+
+  void removeAll(Iterable<Object> elements) => _inner.removeAll(elements);
+
+  void removeWhere(bool test(String element)) => _inner.removeWhere(test);
+
+  void retainAll(Iterable<Object> elements) => _inner.retainAll(elements);
+
+  Set<T> retype<T>() => _inner.retype<T>();
+
+  void retainWhere(bool test(String element)) => _inner.retainWhere(test);
+
+  Set<String> union(Set<String> other) => _inner.union(other);
+
+  Set<String> toSet() => _inner.toSet();
+}
diff --git a/pubspec.yaml b/pubspec.yaml
index 30a8dff..a9a4cdb 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: path
-version: 1.5.1
+version: 1.6.0
 author: Dart Team <misc@dartlang.org>
 description: >
  A string-based path manipulation library. All of the path operations you know
@@ -9,4 +9,4 @@
 dev_dependencies:
   test: ">=0.12.0 <0.13.0"
 environment:
-  sdk: ">=1.0.0 <2.0.0"
+  sdk: ">=2.0.0-dev.35.0 <2.0.0"
diff --git a/test/path_map_test.dart b/test/path_map_test.dart
new file mode 100644
index 0000000..ce025db
--- /dev/null
+++ b/test/path_map_test.dart
@@ -0,0 +1,80 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test/test.dart';
+
+import 'package:path/path.dart';
+
+void main() {
+  group("considers equal", () {
+    test("two identical paths", () {
+      var map = new PathMap<int>();
+      map[join("foo", "bar")] = 1;
+      map[join("foo", "bar")] = 2;
+      expect(map, hasLength(1));
+      expect(map, containsPair(join("foo", "bar"), 2));
+    });
+
+    test("two logically equivalent paths", () {
+      var map = new PathMap<int>();
+      map["foo"] = 1;
+      map[absolute("foo")] = 2;
+      expect(map, hasLength(1));
+      expect(map, containsPair("foo", 2));
+      expect(map, containsPair(absolute("foo"), 2));
+    });
+
+    test("two nulls", () {
+      var map = new PathMap<int>();
+      map[null] = 1;
+      map[null] = 2;
+      expect(map, hasLength(1));
+      expect(map, containsPair(null, 2));
+    });
+  });
+
+  group("considers unequal", () {
+    test("two distinct paths", () {
+      var map = new PathMap<int>();
+      map["foo"] = 1;
+      map["bar"] = 2;
+      expect(map, hasLength(2));
+      expect(map, containsPair("foo", 1));
+      expect(map, containsPair("bar", 2));
+    });
+
+    test("a path and null", () {
+      var map = new PathMap<int>();
+      map["foo"] = 1;
+      map[null] = 2;
+      expect(map, hasLength(2));
+      expect(map, containsPair("foo", 1));
+      expect(map, containsPair(null, 2));
+    });
+  });
+
+  test("uses the custom context", () {
+    var map = new PathMap<int>(context: windows);
+    map["FOO"] = 1;
+    map["foo"] = 2;
+    expect(map, hasLength(1));
+    expect(map, containsPair("fOo", 2));
+  });
+
+  group(".of()", () {
+    test("copies the existing map's keys", () {
+      var map = new PathMap.of({"foo": 1, "bar": 2});
+      expect(map, hasLength(2));
+      expect(map, containsPair("foo", 1));
+      expect(map, containsPair("bar", 2));
+    });
+
+    test("uses the second value in the case of duplicates", () {
+      var map = new PathMap.of({"foo": 1, absolute("foo"): 2});
+      expect(map, hasLength(1));
+      expect(map, containsPair("foo", 2));
+      expect(map, containsPair(absolute("foo"), 2));
+    });
+  });
+}
diff --git a/test/path_set_test.dart b/test/path_set_test.dart
new file mode 100644
index 0000000..884c184
--- /dev/null
+++ b/test/path_set_test.dart
@@ -0,0 +1,81 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test/test.dart';
+
+import 'package:path/path.dart';
+
+void main() {
+  group("considers equal", () {
+    test("two identical paths", () {
+      var set = new PathSet();
+      expect(set.add(join("foo", "bar")), isTrue);
+      expect(set.add(join("foo", "bar")), isFalse);
+      expect(set, hasLength(1));
+      expect(set, contains(join("foo", "bar")));
+    });
+
+    test("two logically equivalent paths", () {
+      var set = new PathSet();
+      expect(set.add("foo"), isTrue);
+      expect(set.add(absolute("foo")), isFalse);
+      expect(set, hasLength(1));
+      expect(set, contains("foo"));
+      expect(set, contains(absolute("foo")));
+    });
+
+    test("two nulls", () {
+      var set = new PathSet();
+      expect(set.add(null), isTrue);
+      expect(set.add(null), isFalse);
+      expect(set, hasLength(1));
+      expect(set, contains(null));
+    });
+  });
+
+  group("considers unequal", () {
+    test("two distinct paths", () {
+      var set = new PathSet();
+      expect(set.add("foo"), isTrue);
+      expect(set.add("bar"), isTrue);
+      expect(set, hasLength(2));
+      expect(set, contains("foo"));
+      expect(set, contains("bar"));
+    });
+
+    test("a path and null", () {
+      var set = new PathSet();
+      expect(set.add("foo"), isTrue);
+      expect(set.add(null), isTrue);
+      expect(set, hasLength(2));
+      expect(set, contains("foo"));
+      expect(set, contains(null));
+    });
+  });
+
+  test("uses the custom context", () {
+    var set = new PathSet(context: windows);
+    expect(set.add("FOO"), isTrue);
+    expect(set.add("foo"), isFalse);
+    expect(set, hasLength(1));
+    expect(set, contains("fOo"));
+  });
+
+  group(".of()", () {
+    test("copies the existing set's keys", () {
+      var set = new PathSet.of(["foo", "bar"]);
+      expect(set, hasLength(2));
+      expect(set, contains("foo"));
+      expect(set, contains("bar"));
+    });
+
+    test("uses the first value in the case of duplicates", () {
+      var set = new PathSet.of(["foo", absolute("foo")]);
+      expect(set, hasLength(1));
+      expect(set, contains("foo"));
+      expect(set, contains(absolute("foo")));
+      expect(set.first, "foo");
+    });
+  });
+}