Hacking.

Author: davidmorgan

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

@@ -205,7 +205,7 @@ class _MacOSDirectoryWatcher
     // as the directory's full content will be listed.
     var createdDirectories = unionAll(batch.map((event) {
       return event.type == EventType.createDirectory
-          ? event.paths
+          ? {event.path}
           : const <String>{};
     }));
 
@@ -241,73 +241,26 @@ class _MacOSDirectoryWatcher
   /// indicate that the state of the path on the filesystem should be checked to
   /// determine what occurred.
   Event? _canonicalEvent(Set<Event> batch) {
-    // An empty batch indicates that we've learned earlier that the batch is
-    // 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;
-
-    for (var event in batch.skip(1)) {
-      // If one event reports that the file is a directory and another event
-      // doesn't, that's a contradiction.
-      if (isDirectory != event.isDirectory) return null;
-
-      // Modify events don't contradict either CREATE or REMOVE events. We can
-      // safely assume the file was modified after a CREATE or before the
-      // REMOVE; otherwise there will also be a REMOVE or CREATE event
-      // (respectively) that will be contradictory.
-      if (event.type == EventType.modifyFile) {
-        hadModifyEvent = true;
-        continue;
-      }
-      assert(event.isCreate || event.isDelete);
+    var types = batch.map((e) => e.type).toSet();
 
-      // 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.modifyFile) {
-        type = event.type;
-        continue;
+    if (types.length == 2 &&
+        types.contains(EventType.modifyFile) &&
+        types.contains(EventType.createFile)) {
+      if (_files.contains(path)) {
+        types.remove(EventType.createFile);
+      } else {
+        types.remove(EventType.modifyFile);
       }
-
-      // A CREATE event contradicts a REMOVE event and vice versa.
-      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.createFile &&
-        hadModifyEvent &&
-        _files.contains(path)) {
-      type = EventType.modifyFile;
+    if (types.length != 1) {
+      return null;
     }
 
-    switch (type) {
-      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.
-        return null;
-
-      case EventType.createFile:
-      case EventType.delete:
-      case EventType.modifyFile:
-        return batch.firstWhere((e) => e.type == type);
-
-      // Guaranteed not present by `_sortEvents`.
-      case EventType.moveFile:
-      case EventType.moveDirectory:
-      case EventType.modifyDirectory:
-        throw StateError(type.name);
-    }
+    final type = types.first;
+    return batch.firstWhere((e) => e.type == type);
   }
 
   /// Returns one or more events that describe the change between the last known

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

@@ -255,7 +255,8 @@ class _WindowsDirectoryWatcher
       batch.map((event) {
         if (event.type == EventType.createDirectory ||
             event.type == EventType.moveDirectory) {
-          return event.paths;
+          final destination = event.destination;
+          return {event.path, if (destination != null) destination};
         }
         return const <String>{};
       }),
@@ -273,8 +274,10 @@ class _WindowsDirectoryWatcher
       if (event.type == EventType.modifyDirectory) {
         continue;
       }
-      for (final path in event.paths) {
-        addEvent(path, event);
+      addEvent(path, event);
+      final destination = event.destination;
+      if (destination != null) {
+        addEvent(destination, event);
       }
     }
 
@@ -292,57 +295,21 @@ class _WindowsDirectoryWatcher
   /// indicate that the state of the path on the filesystem should be checked to
   /// determine what occurred.
   Event? _canonicalEvent(Set<Event> batch) {
-    // An empty batch indicates that we've learned earlier that the batch is
-    // contradictory (e.g. because of a move).
     if (batch.isEmpty) return null;
+    var types = batch.map((e) => e.type).toSet();
 
-    var type = batch.first.type;
-    var isDirectory = batch.first.isDirectory;
-
-    for (var event in batch.skip(1)) {
-      // If one event reports that the file is a directory and another event
-      // doesn't, that's a contradiction.
-      if (isDirectory != event.isDirectory) return null;
-
-      // Modify events don't contradict either CREATE or REMOVE events. We can
-      // safely assume the file was modified after a CREATE or before the
-      // REMOVE; otherwise there will also be a REMOVE or CREATE event
-      // (respectively) that will be contradictory.
-      if (event.isModify) continue;
-      assert(
-        event.isCreate || event.isDelete || event.isMove,
-      );
-
-      // 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.modifyFile) {
-        type = event.type;
-        continue;
-      }
-
-      // A CREATE event contradicts a REMOVE event and vice versa.
-      assert(type == EventType.createFile ||
-          type == EventType.createDirectory ||
-          type == EventType.delete ||
-          type == EventType.moveFile);
-      if (type != event.type) return null;
+    if (types.length == 2 &&
+        types.contains(EventType.modifyFile) &&
+        types.contains(EventType.createFile)) {
+      types.remove(EventType.modifyFile);
     }
 
-    switch (type) {
-      // Move events are always resolved by checking the filesystem state.
-      case EventType.moveFile:
-      case EventType.moveDirectory:
-        return null;
-
-      case EventType.createFile:
-      case EventType.createDirectory:
-      case EventType.delete:
-      case EventType.modifyFile:
-        return batch.firstWhere((e) => e.type == type);
-
-      case EventType.modifyDirectory:
-        throw StateError(EventType.modifyDirectory.name);
+    if (types.length != 1) {
+      return null;
     }
+
+    final type = types.first;
+    return batch.firstWhere((e) => e.type == type);
   }
 
   /// Returns zero or more events that describe the change between the last

pkgs/watcher/lib/src/event.dart

@@ -76,19 +76,12 @@ extension type Event(FileSystemEvent event) {
   /// For other types of event, always `null`.
   String? get destination =>
       isMove ? (event as FileSystemMoveEvent).destination : null;
-
-  /// See [FileSystemEvent.isDirectory].
-  ///
-  /// For delete events, always `null`.
-  bool? get isDirectory => isDelete ? null : event.isDirectory;
-
-  /// All paths mentioned by the event.
-  ///
-  /// This is [path] plus, for move events, [destination] if it's not `null`.
-  Set<String> get paths => {event.path, if (destination != null) destination!};
 }
 
 /// See [FileSystemEvent.type].
+///
+/// This additionally encodes [FileSystemEvent.isDirectory], which is specified
+/// for all event types except deletes.
 enum EventType {
   delete,
   createFile,