Fix typos in FileSystemEntity.watch documentation.

sdk/lib/io/file_system_entity.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.
 
 part of dart.io;
 
 class FileSystemEntityType {
   static const FILE = const FileSystemEntityType._internal(0);
   static const DIRECTORY = const FileSystemEntityType._internal(1);
   static const LINK = const FileSystemEntityType._internal(2);
@@ skipping 322 matching lines @@
    * This behavior allows [deleteSync] to be used to unconditionally delete any
    * file system object.
    *
    * Throws an exception if the [FileSystemEntity] cannot be deleted.
    */
   void deleteSync({bool recursive: false})
       => _deleteSync(recursive: recursive);
 
 
   /**
-   * Start watch the [FileSystemEntity] for changes.
+   * Start watching the [FileSystemEntity] for changes.
    *
-   * The implementation uses platform-depending event-based APIs for receiving
-   * file-system notifixations, thus behvaiour depends on the platform.
+   * The implementation uses platform-dependent event-based APIs for receiving
+   * file-system notifications, thus behavior depends on the platform.
    *
-   *   * `Windows`: Uses `ReadDirectoryChangesW`. The implementation supports
-   *     only watching dirctories but supports recursive watching.
+   *   * `Windows`: Uses `ReadDirectoryChangesW`. The implementation only
+   *     supports watching directories. Recursive watching is supported.
    *   * `Linux`: Uses `inotify`. The implementation supports watching both
-   *     files and dirctories, but doesn't support recursive watching.
+   *     files and directories. Recursive watching is not supported.
    *   * `Mac OS`: Uses `FSEvents`. The implementation supports watching both
-   *     files and dirctories, and also recursive watching. Note that FSEvents
-   *     always use recursion internally, so when disabled, some events are
-   *     ignored.
+   *     files and directories. Recursive watching is supported.
    *
-   * The system will start listen for events once the returned [Stream] is
+   * The system will start listening for events once the returned [Stream] is
    * being listened to, not when the call to [watch] is issued. Note that the
-   * returned [Stream] is endless. To stop the [Stream], simply cancel the
-   * subscription.
+   * returned [Stream] is endless. To stop the [Stream], cancel the subscription.
    */
   Stream<FileSystemEvent> watch({int events: FileSystemEvent.ALL,
                                  bool recursive: false})
      => new _FileSystemWatcher(_trimTrailingPathSeparators(path),
                                events,
                                recursive).stream;
 
   Future<FileSystemEntity> _delete({bool recursive: false});
   void _deleteSync({bool recursive: false});
 
@@ skipping 333 matching lines @@
   }
 }
 
 
 abstract class _FileSystemWatcher {
   external factory _FileSystemWatcher(String path, int events, bool recursive);
   external static bool get isSupported;
 
   Stream<FileSystemEvent> get stream;
 }