added bool type to named args in lib/io and lib/_internal

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 298 matching lines @@
    *
    * If [recursive] is true, the [FileSystemEntity] is deleted even if the type
    * of the [FileSystemEntity] doesn't match the content of the file system.
    * This behavior allows [delete] to be used to unconditionally delete any file
    * system object.
    *
    * Returns a [:Future<FileSystemEntity>:] that completes with this
    * [FileSystemEntity] when the deletion is done. If the [FileSystemEntity]
    * cannot be deleted, the future completes with an exception.
    */
-  Future<FileSystemEntity> delete({recursive: false})
+  Future<FileSystemEntity> delete({bool recursive: false})
       => _delete(recursive: recursive);
 
   /**
    * Synchronously deletes this [FileSystemEntity].
    *
    * If the [FileSystemEntity] is a directory, and if [recursive] is false,
    * the directory must be empty. Otherwise, if [recursive] is true, the
    * directory and all sub-directories and files in the directories are
    * deleted. Links are not followed when deleting recursively. Only the link
    * is deleted, not its target.
    *
    * If [recursive] is true, the [FileSystemEntity] is deleted even if the type
    * of the [FileSystemEntity] doesn't match the content of the file system.
    * 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({recursive: false})
+  void deleteSync({bool recursive: false})
       => _deleteSync(recursive: recursive);
 
 
   /**
    * Start watch the [FileSystemEntity] for changes.
    *
    * The implementation uses platform-depending event-based APIs for receiving
    * file-system notifixations, thus behvaiour depends on the platform.
    *
    *   * `Windows`: Uses `ReadDirectoryChangesW`. The implementation supports
    *     only watching dirctories but supports recursive watching.
    *   * `Linux`: Uses `inotify`. The implementation supports watching both
    *     files and dirctories, but doesn't support recursive watching.
    *   * `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.
    *
    * The system will start listen 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.
    */
   Stream<FileSystemEvent> watch({int events: FileSystemEvent.ALL,
                                  bool recursive: false})
      => new _FileSystemWatcher(_trimTrailingPathSeparators(path),
                                events,
                                recursive).stream;
 
-  Future<FileSystemEntity> _delete({recursive: false});
-  void _deleteSync({recursive: false});
+  Future<FileSystemEntity> _delete({bool recursive: false});
+  void _deleteSync({bool recursive: false});
 
   /**
    * Checks whether two paths refer to the same object in the
    * file system. Returns a [:Future<bool>:] that completes with the result.
    *
    * Comparing a link to its target returns false, as does comparing two links
    * that point to the same target.  To check the target of a link, use
    * Link.target explicitly to fetch it.  Directory links appearing
    * inside a path are followed, though, to find the file system object.
    *
@@ skipping 281 matching lines @@
   }
 }
 
 
 abstract class _FileSystemWatcher {
   external factory _FileSystemWatcher(String path, int events, bool recursive);
   external static bool get isSupported;
 
   Stream<FileSystemEvent> get stream;
 }