Update the Linux watcher to accommodate changes in [Directory.watch].

pkg/watcher/lib/src/directory_watcher/linux.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.linux;
 
 import 'dart:async';
 import 'dart:io';
 
 import '../utils.dart';
@@ skipping 195 matching lines @@
       if (oldState != _EntryState.FILE && newState == _EntryState.FILE) {
         emitEvent(ChangeType.ADD);
       } else if (oldState == _EntryState.FILE && newState == _EntryState.FILE) {
         emitEvent(ChangeType.MODIFY);
       } else if (oldState == _EntryState.FILE && newState != _EntryState.FILE) {
         emitEvent(ChangeType.REMOVE);
       }
 
       if (oldState == _EntryState.DIRECTORY) {
         var watcher = _subWatchers.remove(path);
-        if (watcher == null) return;
+        if (watcher == null) continue;
         for (var path in watcher._allFiles) {
           _eventsController.add(new WatchEvent(ChangeType.REMOVE, path));
         }
         watcher.close();
       }
 
       if (newState == _EntryState.DIRECTORY) _watchSubdir(path);
     }
   }
 
@@ skipping 13 matching lines @@
     if (event is FileSystemDeleteEvent) return ChangeType.REMOVE;
     if (event is FileSystemCreateEvent) return ChangeType.ADD;
 
     assert(event is FileSystemModifyEvent);
     return ChangeType.MODIFY;
   }
 
   /// Handles the underlying event stream closing, indicating that the directory
   /// being watched was removed.
   void _onDone() {
+    // Most of the time when a directory is removed, its contents will get
+    // individual REMOVE events before the watch stream is closed -- in that
+    // case, [_entries] will be empty here. However, if the directory's removal
+    // is caused by a MOVE, we need to manually emit events.
+    if (isReady) {
+      _entries.forEach((path, state) {
+        if (state == _EntryState.DIRECTORY) return;
+        _eventsController.add(new WatchEvent(ChangeType.REMOVE, path));
+      });
+    }
+
     // The parent directory often gets a close event before the subdirectories
     // are done emitting events. We wait for them to finish before we close
     // [events] so that we can be sure to emit a remove event for every file
     // that used to exist.
     Future.wait(_subWatchers.values.map((watcher) {
       try {
         return watcher.events.toList();
       } on StateError catch (_) {
         // It's possible that [watcher.events] is closed but the onDone event
         // hasn't reached us yet. It's fine if so.
@@ skipping 26 matching lines @@
   static const DIRECTORY = const _EntryState._("directory");
 
   const _EntryState._(this._name);
 
   /// Returns [DIRECTORY] if [isDir] is true, and [FILE] otherwise.
   factory _EntryState(bool isDir) =>
       isDir ? _EntryState.DIRECTORY : _EntryState.FILE;
 
   String toString() => _name;
 }