Hacking.

Author: davidmorgan

pkgs/watcher/lib/src/directory_watcher/linux.dart

@@ -163,30 +163,35 @@ class _LinuxDirectoryWatcher
 
       changed.add(event.path);
 
-      if (event.isMove) {
-        files.remove(event.path);
-        dirs.remove(event.path);
-
-        var destination = event.destination;
-        if (destination == null) continue;
+      switch (event.type) {
+        case EventType.delete:
+          files.remove(event.path);
+          dirs.remove(event.path);
+
+        case EventType.moveFile:
+          files.remove(event.path);
+          var destination = event.destination;
+          if (destination == null) continue;
+          changed.add(destination);
+          files.add(destination);
+          dirs.remove(destination);
 
-        changed.add(destination);
-        if (event.isDirectory!) {
+        case EventType.moveDirectory:
+          dirs.remove(event.path);
+          var destination = event.destination;
+          if (destination == null) continue;
           files.remove(destination);
           dirs.add(destination);
-        } else {
-          files.add(destination);
-          dirs.remove(destination);
-        }
-      } else if (event is FileSystemDeleteEvent) {
-        files.remove(event.path);
-        dirs.remove(event.path);
-      } else if (event.isDirectory!) {
-        files.remove(event.path);
-        dirs.add(event.path);
-      } else {
-        files.add(event.path);
-        dirs.remove(event.path);
+
+        case EventType.createFile:
+        case EventType.modifyFile:
+          files.add(event.path);
+          dirs.remove(event.path);
+
+        case EventType.createDirectory:
+        case EventType.modifyDirectory:
+          files.remove(event.path);
+          dirs.add(event.path);
       }
     }
 

pkgs/watcher/lib/src/directory_watcher/mac_os.dart

@@ -133,8 +133,8 @@ class _MacOSDirectoryWatcher
           : [canonicalEvent];
 
       for (var event in events) {
-        if (event.isCreate) {
-          if (!event.isDirectory!) {
+        switch (event.type) {
+          case EventType.createFile:
             // If we already know about the file, treat it like a modification.
             // This can happen if a file is copied on top of an existing one.
             // We'll see an ADD event for the latter file when from the user's
@@ -144,47 +144,57 @@ class _MacOSDirectoryWatcher
 
             _emitEvent(type, path);
             _files.add(path);
-            continue;
-          }
-
-          if (_files.containsDir(path)) continue;
-
-          var stream = Directory(path)
-              .list(recursive: true)
-              .ignoring<PathNotFoundException>();
-          var subscription = stream.listen((entity) {
-            if (entity is Directory) return;
-            if (_files.contains(path)) return;
-
-            _emitEvent(ChangeType.ADD, entity.path);
-            _files.add(entity.path);
-          }, cancelOnError: true);
-          subscription.onDone(() {
-            _listSubscriptions.remove(subscription);
-          });
-          subscription.onError(_emitError);
-          _listSubscriptions.add(subscription);
-        } else if (event.isModify) {
-          assert(!event.isDirectory!);
-          _emitEvent(ChangeType.MODIFY, path);
-        } else {
-          assert(event.isDelete);
-          for (var removedPath in _files.remove(path)) {
-            _emitEvent(ChangeType.REMOVE, removedPath);
-          }
+
+          case EventType.createDirectory:
+            if (_files.containsDir(path)) continue;
+
+            var stream = Directory(path)
+                .list(recursive: true)
+                .ignoring<PathNotFoundException>();
+            var subscription = stream.listen((entity) {
+              if (entity is Directory) return;
+              if (_files.contains(path)) return;
+
+              _emitEvent(ChangeType.ADD, entity.path);
+              _files.add(entity.path);
+            }, cancelOnError: true);
+            subscription.onDone(() {
+              _listSubscriptions.remove(subscription);
+            });
+            subscription.onError(_emitError);
+            _listSubscriptions.add(subscription);
+
+          case EventType.modifyFile:
+            _emitEvent(ChangeType.MODIFY, path);
+
+          case EventType.delete:
+            for (var removedPath in _files.remove(path)) {
+              _emitEvent(ChangeType.REMOVE, removedPath);
+            }
+
+          // TODO(davidmorgan): explain.
+          case EventType.modifyDirectory:
+            throw ArgumentError();
+
+          // No move events on MacOS.
+          case EventType.moveFile:
+          case EventType.moveDirectory:
+            throw ArgumentError();
         }
       }
     });
   }
 
   /// Sort all the events in a batch into sets based on their path.
   ///
-  /// A single input event may result in multiple events in the returned map;
-  /// for example, a MOVE event becomes a DELETE event for the source and a
-  /// CREATE event for the destination.
+  /// Events for `path` are discarded.
+  ///
+  /// Events under directories that are created or modified are discarded.
   ///
-  /// The returned events won't contain any [FileSystemMoveEvent]s, nor will it
-  /// contain any events relating to [path].
+  /// There should already be no [EventType.moveFile] or
+  /// [EventType.moveDirectory] events because the SDK does not send any on
+  /// MacOS. See https://github.com/dart-lang/sdk/issues/14806. If there are
+  /// any, they are dropped.
   Map<String, Set<Event>> _sortEvents(List<Event> batch) {
     var eventsForPaths = <String, Set<Event>>{};
 
@@ -193,9 +203,10 @@ class _MacOSDirectoryWatcher
     // really deleted, that's handled by [_onDone].
     batch = batch.where((event) => event.path != path).toList();
 
-    // Events within directories that already have events are superfluous; the
-    // directory's full contents will be examined anyway, so we ignore such
-    // events. Emitting them could cause useless or out-of-order events.
+    // Events within directories that already have create or modify events are
+    // superfluous; the directory's full contents will be examined anyway, so we
+    // ignore such events. Emitting them could cause useless or out-of-order
+    // events.
     var directories = unionAll(batch.map((event) {
       if (event.isDelete || !event.isDirectory!) return <String>{};
       return event.paths;
@@ -210,8 +221,7 @@ class _MacOSDirectoryWatcher
     }
 
     for (var event in batch) {
-      // The Mac OS watcher doesn't emit move events. See issue 14806.
-      assert(!event.isMove);
+      if (event.isMove) continue;
       addEvent(event.path, event);
     }
 
@@ -233,6 +243,7 @@ class _MacOSDirectoryWatcher
     // contradictory (e.g. because of a move).
     if (batch.isEmpty) return null;
 
+    var path = batch.first.path;
     var type = batch.first.type;
     var isDirectory = batch.first.isDirectory;
     var hadModifyEvent = false;
@@ -254,42 +265,50 @@ class _MacOSDirectoryWatcher
 
       // If we previously thought this was a MODIFY, we now consider it to be a
       // CREATE or REMOVE event. This is safe for the same reason as above.
-      if (type == EventType.modify) {
+      if (type == EventType.modifyFile || type == EventType.modifyDirectory) {
         type = event.type;
         continue;
       }
 
       // A CREATE event contradicts a REMOVE event and vice versa.
-      assert(type == EventType.create || type == EventType.delete);
+      assert(type == EventType.createFile ||
+          type == EventType.createDirectory ||
+          type == EventType.delete);
       if (type != event.type) return null;
     }
 
     // If we got a CREATE event for a file we already knew about, that comes
     // from FSEvents reporting an add that happened prior to the watch
     // beginning. If we also received a MODIFY event, we want to report that,
     // but not the CREATE.
-    if (type == EventType.create &&
+    if (type == EventType.createFile &&
         hadModifyEvent &&
-        _files.contains(batch.first.path)) {
-      type = EventType.modify;
+        _files.contains(path)) {
+      type = EventType.modifyFile;
     }
 
     switch (type) {
-      case EventType.create:
+      case EventType.createDirectory:
         // Issue 16003 means that a CREATE event for a directory can indicate
         // that the directory was moved and then re-created.
         // [_eventsBasedOnFileSystem] will handle this correctly by producing a
         // DELETE event followed by a CREATE event if the directory exists.
-        if (isDirectory!) return null;
-        return Event.createFile(batch.first.path);
+        return null;
+      case EventType.createFile:
+        return Event.createFile(path);
+
       case EventType.delete:
-        return Event.delete(batch.first.path);
-      case EventType.modify:
-        return isDirectory!
-            ? Event.modifyDirectory(batch.first.path)
-            : Event.modifyFile(batch.first.path);
-      default:
-        throw StateError('unreachable');
+        return Event.delete(path);
+
+      case EventType.modifyFile:
+        return Event.modifyFile(path);
+      case EventType.modifyDirectory:
+        return Event.modifyDirectory(path);
+
+      // No move events on MacOS.
+      case EventType.moveFile:
+      case EventType.moveDirectory:
+        throw ArgumentError();
     }
   }