Update the Mac OS watcher in pkg/watcher.

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

 // Copyright (c) 2013, 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.
 
 library watcher.directory_watcher.mac_os;
 
 import 'dart:async';
 import 'dart:io';
 
 import '../constructable_file_system_event.dart';
 import '../path_set.dart';
 import '../utils.dart';
 import '../watch_event.dart';
 import 'resubscribable.dart';
 
 /// Uses the FSEvents subsystem to watch for filesystem events.
 ///
 /// FSEvents has two main idiosyncrasies that this class works around. First, it
 /// will occasionally report events that occurred before the filesystem watch
 /// was initiated. Second, if multiple events happen to the same file in close
 /// succession, it won't report them in the order they occurred. See issue
 /// 14373.
 ///
-/// This also works around issues 14793, 14806, and 14849 in the implementation
-/// of [Directory.watch].
+/// This also works around issues 15458 and 14849 in the implementation of
+/// [Directory.watch].
 class MacOSDirectoryWatcher extends ResubscribableDirectoryWatcher {
   MacOSDirectoryWatcher(String directory)
       : super(directory, () => new _MacOSDirectoryWatcher(directory));
 }
 
 class _MacOSDirectoryWatcher implements ManuallyClosedDirectoryWatcher {
   final String directory;
 
   Stream<WatchEvent> get events => _eventsController.stream;
   final _eventsController = new StreamController<WatchEvent>.broadcast();
@@ skipping 61 matching lines @@
     batches++;
 
     _sortEvents(batch).forEach((path, events) {
       var canonicalEvent = _canonicalEvent(events);
       events = canonicalEvent == null ?
           _eventsBasedOnFileSystem(path) : [canonicalEvent];
 
       for (var event in events) {
         if (event is FileSystemCreateEvent) {
           if (!event.isDirectory) {
+            // Don't emit ADD events for files or directories that we already
+            // know about. Such an event comes from FSEvents reporting an add
+            // that happened prior to the watch beginning.
+            if (_files.contains(path)) continue;
+
             _emitEvent(ChangeType.ADD, path);
             _files.add(path);
             continue;
           }
 
+          if (_files.containsDir(path)) continue;
+
           _listen(new Directory(path).list(recursive: true), (entity) {
             if (entity is Directory) return;
             _emitEvent(ChangeType.ADD, entity.path);
             _files.add(entity.path);
           }, onError: _emitError, cancelOnError: true);
         } else if (event is FileSystemModifyEvent) {
           assert(!event.isDirectory);
           _emitEvent(ChangeType.MODIFY, path);
         } else {
           assert(event is FileSystemDeleteEvent);
@@ skipping 32 matching lines @@
 
     isInModifiedDirectory(path) =>
         directories.any((dir) => path != dir && path.startsWith(dir));
 
     addEvent(path, event) {
       if (isInModifiedDirectory(path)) return;
       var set = eventsForPaths.putIfAbsent(path, () => new Set());
       set.add(event);
     }
 
-    for (var event in batch.where((event) => event is! FileSystemMoveEvent)) {
+    for (var event in batch) {
+      // The Mac OS watcher doesn't emit move events. See issue 14806.
+      assert(event is! FileSystemMoveEvent);
       addEvent(event.path, event);
     }
 
-    // Issue 14806 means that move events can be misleading if they're in the
-    // same batch as another modification of a related file. If they are, we
-    // make the event set empty to ensure we check the state of the filesystem.
-    // Otherwise, treat them as a DELETE followed by an ADD.
-    for (var event in batch.where((event) => event is FileSystemMoveEvent)) {
-      if (eventsForPaths.containsKey(event.path) ||
-          eventsForPaths.containsKey(event.destination)) {
-
-        if (!isInModifiedDirectory(event.path)) {
-          eventsForPaths[event.path] = new Set();
-        }
-        if (!isInModifiedDirectory(event.destination)) {
-          eventsForPaths[event.destination] = new Set();
-        }
-
-        continue;
-      }
-
-      addEvent(event.path, new ConstructableFileSystemDeleteEvent(
-          event.path, event.isDirectory));
-      addEvent(event.destination, new ConstructableFileSystemCreateEvent(
-          event.path, event.isDirectory));
-    }
-
     return eventsForPaths;
   }
 
   /// Returns the canonical event from a batch of events on the same path, if
   /// one exists.
   ///
   /// If [batch] doesn't contain any contradictory events (e.g. DELETE and
   /// CREATE, or events with different values for [isDirectory]), this returns a
   /// single event that describes what happened to the path in question.
   ///
   /// If [batch] does contain contradictory events, this returns `null` to
   /// indicate that the state of the path on the filesystem should be checked to
   /// determine what occurred.
   FileSystemEvent _canonicalEvent(Set<FileSystemEvent> 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 type = batch.first.type;
     var isDir = 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 (isDir != 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 is FileSystemModifyEvent) continue;
+      if (event is FileSystemModifyEvent) {
+        hadModifyEvent = true;
+        continue;
+      }
       assert(event is FileSystemCreateEvent || event is FileSystemDeleteEvent);
 
       // 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 == FileSystemEvent.MODIFY) {
         type = event.type;
         continue;
       }
 
       // A CREATE event contradicts a REMOVE event and vice versa.
       assert(type == FileSystemEvent.CREATE || type == FileSystemEvent.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 == FileSystemEvent.CREATE && hadModifyEvent &&
+        _files.contains(batch.first.path)) {
+      type = FileSystemEvent.MODIFY;
+    }
+
     switch (type) {
       case FileSystemEvent.CREATE:
-        // Issue 14793 means that CREATE events can actually mean DELETE, so we
-        // should always check the filesystem for them.
-        return null;
+        return new ConstructableFileSystemCreateEvent(batch.first.path, isDir);
       case FileSystemEvent.DELETE:
-        return new ConstructableFileSystemDeleteEvent(batch.first.path, isDir);
+        // Issue 15458 means that DELETE events for directories can actually
+        // mean CREATE, so we always check the filesystem for them.
+        if (isDir) return null;
+        return new ConstructableFileSystemCreateEvent(batch.first.path, false);
       case FileSystemEvent.MODIFY:
         return new ConstructableFileSystemModifyEvent(
             batch.first.path, isDir, false);
       default: assert(false);
     }
   }
 
   /// Returns one or more events that describe the change between the last known
   /// state of [path] and its current state on the filesystem.
   ///
@@ skipping 64 matching lines @@
         new BatchedStreamTransformer<FileSystemEvent>());
     _watchSubscription = innerStream.listen(_onBatch,
         onError: _eventsController.addError,
         onDone: _onDone);
   }
 
   /// Emit an event with the given [type] and [path].
   void _emitEvent(ChangeType type, String path) {
     if (!isReady) return;
 
-    // Don't emit ADD events for files that we already know about. Such an event
-    // probably comes from FSEvents reporting an add that happened prior to the
-    // watch beginning.
-    if (type == ChangeType.ADD && _files.contains(path)) return;
-
     _eventsController.add(new WatchEvent(type, path));
   }
 
   /// Emit an error, then close the watcher.
   void _emitError(error, StackTrace stackTrace) {
     _eventsController.addError(error, stackTrace);
     close();
   }
 
   /// Like [Stream.listen], but automatically adds the subscription to
   /// [_subscriptions] so that it can be canceled when [close] is called.
   void _listen(Stream stream, void onData(event), {Function onError,
       void onDone(), bool cancelOnError}) {
     var subscription;
     subscription = stream.listen(onData, onError: onError, onDone: () {
       _subscriptions.remove(subscription);
       if (onDone != null) onDone();
     }, cancelOnError: cancelOnError);
     _subscriptions.add(subscription);
   }
 }