Roll to pickup pool changes

packages/glob/lib/src/list_tree.dart

 // Copyright (c) 2014, 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.
 
+import 'dart:async';
 import 'dart:io';
-import 'dart:async';
 
 import 'package:async/async.dart';
 import 'package:path/path.dart' as p;
 
 import 'ast.dart';
 import 'utils.dart';
 
 /// The errno for a file or directory not existing on Mac and Linux.
 const _ENOENT = 2;
 
@@ skipping 119 matching lines @@
           // On the other hand if there are more components, add [component]
           // to [parent]'s children and not its validator. Since we process
           // each option's components separately, the same component is never
           // both a validator and a child.
           if (!parent.children.containsKey(component)) {
             parent.children[component] = new _ListTreeNode();
           }
           parent = parent.children[component];
         }
       } else if (recursive) {
-        _trees[root] = new _ListTreeNode.recursive(
-            _join(components.sublist(i)));
+        _trees[root] =
+            new _ListTreeNode.recursive(_join(components.sublist(i)));
         return;
       } else if (complete) {
         _trees[root] = new _ListTreeNode()..addOption(component);
       } else {
         _trees[root] = new _ListTreeNode();
         _trees[root].children[component] = new _ListTreeNode();
         parent = _trees[root].children[component];
       }
     }
   }
@@ skipping 28 matching lines @@
       if (seen.contains(entity.path)) return false;
       seen.add(entity.path);
       return true;
     });
   }
 
   /// Synchronosuly list all entities that match this glob beneath [root].
   List<FileSystemEntity> listSync({String root, bool followLinks: true}) {
     if (root == null) root = '.';
 
-    // TODO(nweiz): Remove the explicit annotation when sdk#26139 is fixed.
-    var result = _trees.keys.expand/*<FileSystemEntity>*/((rootDir) {
+    var result = _trees.keys.expand((rootDir) {
       var dir = rootDir == '.' ? root : rootDir;
       return _trees[rootDir].listSync(dir, followLinks: followLinks);
     });
 
     if (!_canOverlap) return result.toList();
 
     // TODO(nweiz): Rather than filtering here, avoid double-listing directories
     // in the first place.
     var seen = new Set<String>();
     return result.where((entity) {
@@ skipping 32 matching lines @@
     return children.keys.first.caseSensitive;
   }
 
   /// Whether this node doesn't itself need to be listed.
   ///
   /// If a node has no validator and all of its children are literal filenames,
   /// there's no need to list its contents. We can just directly traverse into
   /// its children.
   bool get _isIntermediate {
     if (_validator != null) return false;
-    if (!_caseSensitive) return false;
     return children.keys.every((sequence) =>
         sequence.nodes.length == 1 && sequence.nodes.first is LiteralNode);
   }
 
   /// Returns whether listing this node might return overlapping results.
   bool get canOverlap {
     // A recusive node can never overlap with itself, because it will only ever
     // involve a single call to [Directory.list] that's then filtered with
     // [_validator].
     if (isRecursive) return false;
@@ skipping 33 matching lines @@
       var child = children[sequence];
       child.makeRecursive();
       return _join([sequence, child._validator]);
     }), caseSensitive: _caseSensitive);
     children = null;
   }
 
   /// Adds [validator] to this node's existing validator.
   void addOption(SequenceNode validator) {
     if (_validator == null) {
-      _validator = new OptionsNode([validator],
-          caseSensitive: validator.caseSensitive);
+      _validator =
+          new OptionsNode([validator], caseSensitive: validator.caseSensitive);
     } else {
       _validator.options.add(validator);
     }
   }
 
   /// Lists all entities within [dir] matching this node or its children.
   ///
   /// This may return duplicate entities. These will be filtered out in
   /// [ListTree.list].
   Stream<FileSystemEntity> list(String dir, {bool followLinks: true}) {
     if (isRecursive) {
-      return new Directory(dir).list(recursive: true, followLinks: followLinks)
+      return new Directory(dir)
+          .list(recursive: true, followLinks: followLinks)
           .where((entity) => _matches(p.relative(entity.path, from: dir)));
     }
 
-    var resultGroup = new StreamGroup<FileSystemEntity>();
-
     // Don't spawn extra [Directory.list] calls when we already know exactly
     // which subdirectories we're interested in.
-    if (_isIntermediate) {
+    if (_isIntermediate && _caseSensitive) {
+      var resultGroup = new StreamGroup<FileSystemEntity>();
       children.forEach((sequence, child) {
         resultGroup.add(child.list(
             p.join(dir, (sequence.nodes.single as LiteralNode).text),
             followLinks: followLinks));
       });
       resultGroup.close();
       return resultGroup.stream;
     }
 
-    var resultController = new StreamController<FileSystemEntity>(sync: true);
-    resultGroup.add(resultController.stream);
-    new Directory(dir).list(followLinks: followLinks).listen((entity) {
-      var basename = p.relative(entity.path, from: dir);
-      if (_matches(basename)) resultController.add(entity);
+    return StreamCompleter.fromFuture(() async {
+      var entities =
+          await new Directory(dir).list(followLinks: followLinks).toList();
+      await _validateIntermediateChildrenAsync(dir, entities);
 
-      children.forEach((sequence, child) {
-        if (entity is! Directory) return;
-        if (!sequence.matches(basename)) return;
-        var stream = child.list(p.join(dir, basename), followLinks: followLinks)
-            .handleError((_) {}, test: (error) {
-          // Ignore errors from directories not existing. We do this here so
-          // that we only ignore warnings below wild cards. For example, the
-          // glob "foo/bar/*/baz" should fail if "foo/bar" doesn't exist but
-          // succeed if "foo/bar/qux/baz" doesn't exist.
-          return error is FileSystemException &&
-              (error.osError.errorCode == _ENOENT ||
-              error.osError.errorCode == _ENOENT_WIN);
+      var resultGroup = new StreamGroup<FileSystemEntity>();
+      var resultController = new StreamController<FileSystemEntity>(sync: true);
+      resultGroup.add(resultController.stream);
+      for (var entity in entities) {
+        var basename = p.relative(entity.path, from: dir);
+        if (_matches(basename)) resultController.add(entity);
+
+        children.forEach((sequence, child) {
+          if (entity is! Directory) return;
+          if (!sequence.matches(basename)) return;
+          var stream = child
+              .list(p.join(dir, basename), followLinks: followLinks)
+              .handleError((_) {}, test: (error) {
+            // Ignore errors from directories not existing. We do this here so
+            // that we only ignore warnings below wild cards. For example, the
+            // glob "foo/bar/*/baz" should fail if "foo/bar" doesn't exist but
+            // succeed if "foo/bar/qux/baz" doesn't exist.
+            return error is FileSystemException &&
+                (error.osError.errorCode == _ENOENT ||
+                    error.osError.errorCode == _ENOENT_WIN);
+          });
+          resultGroup.add(stream);
         });
-        resultGroup.add(stream);
-      });
-    },
-        onError: resultController.addError,
-        onDone: () {
-          resultController.close();
-          resultGroup.close();
-        });
+      }
+      resultController.close();
+      resultGroup.close();
+      return resultGroup.stream;
+    }());
+  }
 
-    return resultGroup.stream;
+  /// If this is a case-insensitive list, validates that all intermediate
+  /// children (according to [_isIntermediate]) match at least one entity in
+  /// [entities].
+  ///
+  /// This ensures that listing "foo/bar/*" fails on case-sensitive systems if
+  /// "foo/bar" doesn't exist.
+  Future _validateIntermediateChildrenAsync(
+      String dir, List<FileSystemEntity> entities) async {
+    if (_caseSensitive) return;
+
+    for (var sequence in children.keys) {
+      var child = children[sequence];
+      if (!child._isIntermediate) continue;
+      if (entities.any(
+          (entity) => sequence.matches(p.relative(entity.path, from: dir)))) {
+        continue;
+      }
+
+      // We know this will fail, we're just doing it to force dart:io to emit
+      // the exception it would if we were listing case-sensitively.
+      await child
+          .list(p.join(dir, (sequence.nodes.single as LiteralNode).text))
+          .toList();
+    }
   }
 
   /// Synchronously lists all entities within [dir] matching this node or its
   /// children.
   ///
   /// This may return duplicate entities. These will be filtered out in
   /// [ListTree.listSync].
   Iterable<FileSystemEntity> listSync(String dir, {bool followLinks: true}) {
     if (isRecursive) {
       return new Directory(dir)
           .listSync(recursive: true, followLinks: followLinks)
           .where((entity) => _matches(p.relative(entity.path, from: dir)));
     }
 
     // Don't spawn extra [Directory.listSync] calls when we already know exactly
     // which subdirectories we're interested in.
-    if (_isIntermediate) {
+    if (_isIntermediate && _caseSensitive) {
       return children.keys.expand((sequence) {
         return children[sequence].listSync(
             p.join(dir, (sequence.nodes.single as LiteralNode).text),
             followLinks: followLinks);
       });
     }
 
-    return new Directory(dir).listSync(followLinks: followLinks)
-        .expand((entity) {
+    var entities = new Directory(dir).listSync(followLinks: followLinks);
+    _validateIntermediateChildrenSync(dir, entities);
+
+    return entities.expand((entity) {
       var entities = <FileSystemEntity>[];
       var basename = p.relative(entity.path, from: dir);
       if (_matches(basename)) entities.add(entity);
       if (entity is! Directory) return entities;
 
       entities.addAll(children.keys
           .where((sequence) => sequence.matches(basename))
           .expand((sequence) {
         try {
-          return children[sequence].listSync(
-              p.join(dir, basename), followLinks: followLinks).toList();
+          return children[sequence]
+              .listSync(p.join(dir, basename), followLinks: followLinks)
+              .toList();
         } on FileSystemException catch (error) {
           // Ignore errors from directories not existing. We do this here so
           // that we only ignore warnings below wild cards. For example, the
           // glob "foo/bar/*/baz" should fail if "foo/bar" doesn't exist but
           // succeed if "foo/bar/qux/baz" doesn't exist.
           if (error.osError.errorCode == _ENOENT ||
               error.osError.errorCode == _ENOENT_WIN) {
             return const [];
           } else {
             rethrow;
           }
         }
       }));
 
       return entities;
     });
   }
 
+  /// If this is a case-insensitive list, validates that all intermediate
+  /// children (according to [_isIntermediate]) match at least one entity in
+  /// [entities].
+  ///
+  /// This ensures that listing "foo/bar/*" fails on case-sensitive systems if
+  /// "foo/bar" doesn't exist.
+  void _validateIntermediateChildrenSync(
+      String dir, List<FileSystemEntity> entities) {
+    if (_caseSensitive) return;
+
+    children.forEach((sequence, child) {
+      if (!child._isIntermediate) return;
+      if (entities.any(
+          (entity) => sequence.matches(p.relative(entity.path, from: dir)))) {
+        return;
+      }
+
+      // If there are no [entities] that match [sequence], manually list the
+      // directory to force `dart:io` to throw an error. This allows us to
+      // ensure that listing "foo/bar/*" fails on case-sensitive systems if
+      // "foo/bar" doesn't exist.
+      child.listSync(p.join(dir, (sequence.nodes.single as LiteralNode).text));
+    });
+  }
+
   /// Returns whether the native [path] matches [_validator].
   bool _matches(String path) {
     if (_validator == null) return false;
     return _validator.matches(toPosixPath(p.context, path));
   }
 
   String toString() => "($_validator) $children";
 }
 
 /// Joins each [components] into a new glob where each component is separated by
 /// a path separator.
 SequenceNode _join(Iterable<AstNode> components) {
   var componentsList = components.toList();
   var first = componentsList.removeAt(0);
   var nodes = [first];
   for (var component in componentsList) {
     nodes.add(new LiteralNode('/', caseSensitive: first.caseSensitive));
     nodes.add(component);
   }
   return new SequenceNode(nodes, caseSensitive: first.caseSensitive);
 }