Make listDir always emit paths within the given directory.

utils/pub/io.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.
 
 /**
  * Helper functionality to make working with IO easier.
  */
 library io;
 
 import 'dart:io';
@@ skipping 227 matching lines @@
  * Asynchronously recursively deletes [dir], which can be a [String] or a
  * [Directory]. Returns a [Future] that completes when the deletion is done.
  */
 Future<Directory> deleteDir(dir) {
   dir = _getDirectory(dir);
 
   return _attemptRetryable(() => log.ioAsync("delete directory ${dir.path}",
       dir.delete(recursive: true)));
 }
 
-/**
- * Asynchronously lists the contents of [dir], which can be a [String] directory
- * path or a [Directory]. If [recursive] is `true`, lists subdirectory contents
- * (defaults to `false`). If [includeHiddenFiles] is `true`, includes files and
- * directories beginning with `.` (defaults to `false`).
- */
+/// Asynchronously lists the contents of [dir], which can be a [String]
+/// directory path or a [Directory]. If [recursive] is `true`, lists
+/// subdirectory contents (defaults to `false`). If [includeHiddenFiles] is
+/// `true`, includes files and directories beginning with `.` (defaults to
+/// `false`).
+///
+/// If [dir] is a string, the returned paths are guaranteed to begin with it.
 Future<List<String>> listDir(dir,
     {bool recursive: false, bool includeHiddenFiles: false}) {
-  final completer = new Completer<List<String>>();
-  final contents = <String>[];
+  Future<List<String>> doList(Directory dir, Set<String> listedDirectories) {
+    var contents = <String>[];
+    var completer = new Completer<List<String>>();
 
-  dir = _getDirectory(dir);
-  log.io("Listing directory ${dir.path}.");
-  var lister = dir.list(recursive: recursive);
+    // Avoid recursive symlinks.
+    var resolvedPath = new File(dir.path).fullPathSync();
+    if (listedDirectories.contains(resolvedPath)) {
+      return new Future.immediate([]);
+    }
+    listedDirectories = new Set<String>.from(listedDirectories);
+    listedDirectories.add(resolvedPath);
 
-  lister.onDone = (done) {
-    // TODO(rnystrom): May need to sort here if it turns out onDir and onFile
-    // aren't guaranteed to be called in a certain order. So far, they seem to.
-    if (done) {
-      log.fine("Listed directory ${dir.path}:\n"
-                "${Strings.join(contents, '\n')}");
-      completer.complete(contents);
+    log.io("Listing directory ${dir.path}.");
+    var lister = dir.list();
+
+    lister.onDone = (done) {
+      // TODO(rnystrom): May need to sort here if it turns out onDir and onFile
+      // aren't guaranteed to be called in a certain order. So far, they seem to.
+      if (done) {
+        log.fine("Listed directory ${dir.path}:\n"
+                  "${Strings.join(contents, '\n')}");
+        completer.complete(contents);
+      }
+    };
+
+    // TODO(nweiz): remove this when issue 4061 is fixed.
+    var stackTrace;
+    try {
+      throw "";
+    } catch (_, localStackTrace) {
+      stackTrace = localStackTrace;
     }
-  };
 
-  // TODO(nweiz): remove this when issue 4061 is fixed.
-  var stackTrace;
-  try {
-    throw "";
-  } catch (_, localStackTrace) {
-    stackTrace = localStackTrace;
+    var children = [];
+    lister.onError = (error) => completer.completeException(error, stackTrace);
+    lister.onDir = (file) {
+      if (!includeHiddenFiles && basename(file).startsWith('.')) return;
+      file = join(dir, basename(file));
+      contents.add(file);
+
+      // TODO(nweiz): don't manually recurse once issue 7358 is fixed.
+      if (recursive) {
+        children.add(doList(new Directory(file), listedDirectories));
+      }
+    };
+    lister.onFile = (file) {
+      if (!includeHiddenFiles && basename(file).startsWith('.')) return;
+      contents.add(join(dir, basename(file)));
+    };
+
+    return completer.future.chain((contents) {
+      return Futures.wait(children).transform((childContents) {
+        contents.addAll(flatten(childContents));
+        return contents;
+      });
+    });
   }
 
-  lister.onError = (error) => completer.completeException(error, stackTrace);
-  lister.onDir = (file) {
-    if (!includeHiddenFiles && basename(file).startsWith('.')) return;
-    contents.add(file);
-  };
-  lister.onFile = (file) {
-    if (!includeHiddenFiles && basename(file).startsWith('.')) return;
-    contents.add(file);
-  };
-
-  return completer.future;
+  return doList(_getDirectory(dir), new Set<String>());
 }
 
 /**
  * Asynchronously determines if [dir], which can be a [String] directory path
  * or a [Directory], exists on the file system. Returns a [Future] that
  * completes with the result.
  */
 Future<bool> dirExists(dir) {
   dir = _getDirectory(dir);
   return log.ioAsync("Seeing if directory ${dir.path} exists.",
@@ skipping 691 matching lines @@
   return new Directory(entry);
 }
 
 /**
  * Gets a [Uri] for [uri], which can either already be one, or be a [String].
  */
 Uri _getUri(uri) {
   if (uri is Uri) return uri;
   return new Uri.fromString(uri);
 }