Implement recursive directory deletion.

runtime/bin/file_impl.dart

 // Copyright (c) 2012, 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.
 
 class _FileInputStream extends _BaseDataInputStream implements InputStream {
   _FileInputStream(File file) {
     _file = file.openSync();
     _length = _file.lengthSync();
     _streamMarkedClosed = true;
     _checkScheduleCallbacks();
@@ skipping 484 matching lines @@
       _asyncUsed = false;
 
   void exists() {
     _asyncUsed = true;
     if (_name is !String) {
       if (_errorHandler != null) {
         _errorHandler('File name is not a string: $_name');
       }
       return;
     }
-    var handler =
-        (_existsHandler != null) ? _existsHandler : (result) => null;
     var operation = new _ExistsOperation(_name);
-    _scheduler.enqueue(operation, (result, ignored) { _existsHandler(result); });
+    _scheduler.enqueue(operation, (result, ignored) {
+      var handler =
+          (_existsHandler != null) ? _existsHandler : (result) => null;
+      handler(result);
+    });
   }
 
   bool existsSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     if (_name is !String) {
       throw new FileIOException('File name is not a string: $_name');
     }
     return _FileUtils.exists(_name);
   }
 
   void create() {
     _asyncUsed = true;
-    var handler = (_createHandler != null) ? _createHandler : () => null;
     var handleCreateResult = (created, ignored) {
+      var handler = (_createHandler != null) ? _createHandler : () => null;
       if (created) {
         handler();
       } else if (_errorHandler != null) {
         _errorHandler("Cannot create file: $_name");
       }
     };
     var operation = new _CreateOperation(_name);
     _scheduler.enqueue(operation, handleCreateResult);
   }
 
   void createSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool created = _FileUtils.checkedCreate(_name);
     if (!created) {
       throw new FileIOException("Cannot create file: $_name");
     }
   }
 
   void delete() {
     _asyncUsed = true;
-    var handler = (_deleteHandler != null) ? _deleteHandler : () => null;
     var handleDeleteResult = (created, ignored) {
+      var handler = (_deleteHandler != null) ? _deleteHandler : () => null;
       if (created) {
         handler();
       } else if (_errorHandler != null) {
         _errorHandler("Cannot delete file: $_name");
       }
     };
     var operation = new _DeleteOperation(_name);
     _scheduler.enqueue(operation, handleDeleteResult);
   }
 
@@ skipping 12 matching lines @@
     _asyncUsed = true;
     if (mode != FileMode.READ &&
         mode != FileMode.WRITE &&
         mode != FileMode.APPEND) {
       if (_errorHandler != null) {
         _errorHandler("Unknown file mode. Use FileMode.READ, FileMode.WRITE " +
                       "or FileMode.APPEND.");
         return;
       }
     }
-    // If no open handler is present, close the file immediately to
-    // avoid leaking an open file descriptor.
-    var handler = _openHandler;
-    if (handler === null) {
-      handler = (file) => file.close();
-    }
     var handleOpenResult = (id, ignored) {
+      // If no open handler is present, close the file immediately to
+      // avoid leaking an open file descriptor.
+      var handler = _openHandler;
+      if (handler === null) {
+        handler = (file) => file.close();
+      }
       if (id != 0) {
         var randomAccessFile = new _RandomAccessFile(id, _name);
         handler(randomAccessFile);
       } else if (_errorHandler != null) {
         _errorHandler("Cannot open file: $_name");
       }
     };
     var operation = new _OpenOperation(_name, mode._mode);
     _scheduler.enqueue(operation, handleOpenResult);
   }
@@ skipping 11 matching lines @@
     }
     var id = _FileUtils.checkedOpen(_name, mode._mode);
     if (id == 0) {
       throw new FileIOException("Cannot open file: $_name");
     }
     return new _RandomAccessFile(id, _name);
   }
 
   void fullPath() {
     _asyncUsed = true;
-    var handler = _fullPathHandler;
-    if (handler == null) handler = (path) => null;
     var handleFullPathResult = (result, ignored) {
+      var handler = _fullPathHandler;
+      if (handler == null) handler = (path) => null;
       if (result != null) {
         handler(result);
       } else if (_errorHandler != null) {
         _errorHandler("fullPath failed");
       }
     };
     var operation = new _FullPathOperation(_name);
     _scheduler.enqueue(operation, handleFullPathResult);
   }
 
@@ skipping 53 matching lines @@
 }
 
 
 class _RandomAccessFile implements RandomAccessFile {
   _RandomAccessFile(int this._id, String this._name)
     : _scheduler = new _FileOperationScheduler(),
       _asyncUsed = false;
 
   void close() {
     _asyncUsed = true;
-    var handler = (_closeHandler != null) ? _closeHandler : () => null;
     var handleCloseResult = (result, ignored) {
+      var handler = (_closeHandler != null) ? _closeHandler : () => null;
       if (result != -1) {
         _id = result;
         handler();
       } else if (_errorHandler != null) {
         _errorHandler("Cannot close file: $_name");
       }
     };
     var operation = new _CloseOperation(_id);
     _scheduler.enqueue(operation, handleCloseResult);
   }
 
   void closeSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     var id = _FileUtils.close(_id);
     if (id == -1) {
       throw new FileIOException("Cannot close file: $_name");
     }
     _id = id;
   }
 
   void readByte() {
     _asyncUsed = true;
-    var handler =
-        (_readByteHandler != null) ? _readByteHandler : (byte) => null;
     var handleReadByteResult = (result, ignored) {
+      var handler =
+          (_readByteHandler != null) ? _readByteHandler : (byte) => null;
       if (result != -1) {
         handler(result);
       } else if (_errorHandler != null) {
         _errorHandler("readByte failed");
       }
     };
     var operation = new _ReadByteOperation(_id);
     _scheduler.enqueue(operation, handleReadByteResult);
   }
 
@@ skipping 10 matching lines @@
   }
 
   void readList(List<int> buffer, int offset, int bytes) {
     _asyncUsed = true;
     if (buffer is !List || offset is !int || bytes is !int) {
       if (_errorHandler != null) {
         _errorHandler("Invalid arguments to readList");
       }
       return;
     };
-    var handler =
-        (_readListHandler != null) ? _readListHandler : (result) => null;
     var handleReadListResult = (result, ignored) {
+      var handler =
+          (_readListHandler != null) ? _readListHandler : (result) => null;
       if (result is _ReadListResult && result.read != -1) {
         var read = result.read;
         buffer.setRange(offset, read, result.buffer);
         handler(read);
         return;
       }
       if (_errorHandler != null) {
         _errorHandler(result is String ? result : "readList failed");
       }
     };
@@ skipping 132 matching lines @@
     }
     int result = _FileUtils.checkedWriteString(_id, string);
     if (result == -1) {
       throw new FileIOException("writeString failed");
     }
     return result;
   }
 
   void position() {
     _asyncUsed = true;
-    var handler = (_positionHandler != null) ? _positionHandler : (pos) => null;
     var handlePositionResult = (result, ignored) {
+      var handler =
+          (_positionHandler != null) ? _positionHandler : (pos) => null;
       if (result == -1 && _errorHandler != null) {
         _errorHandler("position failed");
         return;
       }
       handler(result);
     };
     var operation = new _PositionOperation(_id);
     _scheduler.enqueue(operation, handlePositionResult);
   }
 
   int positionSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.position(_id);
     if (result == -1) {
       throw new FileIOException("position failed");
     }
     return result;
   }
 
   void setPosition(int position) {
     _asyncUsed = true;
-    var handler =
-        (_setPositionHandler != null) ? _setPositionHandler : () => null;
     var handleSetPositionResult = (result, ignored) {
+      var handler =
+          (_setPositionHandler != null) ? _setPositionHandler : () => null;
       if (result == false && _errorHandler != null) {
         _errorHandler("setPosition failed");
         return;
       }
       handler();
     };
     var operation = new _SetPositionOperation(_id, position);
     _scheduler.enqueue(operation, handleSetPositionResult);
   }
 
   void setPositionSync(int position) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool result = _FileUtils.setPosition(_id, position);
     if (result == false) {
       throw new FileIOException("setPosition failed");
     }
   }
 
   void truncate(int length) {
     _asyncUsed = true;
-    var handler = (_truncateHandler != null) ? _truncateHandler : () => null;
     var handleTruncateResult = (result, ignored) {
+      var handler = (_truncateHandler != null) ? _truncateHandler : () => null;
       if (result == false && _errorHandler != null) {
         _errorHandler("truncate failed");
         return;
       }
       handler();
     };
     var operation = new _TruncateOperation(_id, length);
     _scheduler.enqueue(operation, handleTruncateResult);
   }
 
   void truncateSync(int length) {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     bool result = _FileUtils.truncate(_id, length);
     if (result == false) {
       throw new FileIOException("truncate failed");
     }
   }
 
   void length() {
     _asyncUsed = true;
-    var handler = (_lengthHandler != null) ? _lengthHandler : (pos) => null;
     var handleLengthResult = (result, ignored) {
+      var handler = (_lengthHandler != null) ? _lengthHandler : (pos) => null;
       if (result == -1 && _errorHandler != null) {
         _errorHandler("length failed");
         return;
       }
       handler(result);
     };
     var operation = new _LengthOperation(_id);
     _scheduler.enqueue(operation, handleLengthResult);
   }
 
   int lengthSync() {
     if (_asyncUsed) {
       throw new FileIOException(
           "Mixed use of synchronous and asynchronous API");
     }
     int result = _FileUtils.length(_id);
     if (result == -1) {
       throw new FileIOException("length failed");
     }
     return result;
   }
 
   void flush() {
     _asyncUsed = true;
-    var handler = (_flushHandler != null) ? _flushHandler : (pos) => null;
     var handleFlushResult = (result, ignored) {
+      var handler = (_flushHandler != null) ? _flushHandler : (pos) => null;
       if (result == -1 && _errorHandler != null) {
         _errorHandler("flush failed");
         return;
       }
       handler();
     };
     var operation = new _FlushOperation(_id);
     _scheduler.enqueue(operation, handleFlushResult);
   }
 
@@ skipping 60 matching lines @@
   var _readByteHandler;
   var _readListHandler;
   var _noPendingWriteHandler;
   var _positionHandler;
   var _setPositionHandler;
   var _truncateHandler;
   var _lengthHandler;
   var _flushHandler;
   var _errorHandler;
 }