Roll to pickup pool changes

packages/glob/lib/glob.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 'package:path/path.dart' as p;
 
 import 'src/ast.dart';
@@ skipping 40 matching lines @@
 
   ListTree _listTree;
 
   /// Whether [context]'s current directory is absolute.
   bool get _contextIsAbsolute {
     if (_contextIsAbsoluteCache == null) {
       _contextIsAbsoluteCache = context.isAbsolute(context.current);
     }
     return _contextIsAbsoluteCache;
   }
+
   bool _contextIsAbsoluteCache;
 
   /// Whether [pattern] could match absolute paths.
   bool get _patternCanMatchAbsolute {
     if (_patternCanMatchAbsoluteCache == null) {
       _patternCanMatchAbsoluteCache = _ast.canMatchAbsolute;
     }
     return _patternCanMatchAbsoluteCache;
   }
+
   bool _patternCanMatchAbsoluteCache;
 
   /// Whether [pattern] could match relative paths.
   bool get _patternCanMatchRelative {
     if (_patternCanMatchRelativeCache == null) {
       _patternCanMatchRelativeCache = _ast.canMatchRelative;
     }
     return _patternCanMatchRelativeCache;
   }
+
   bool _patternCanMatchRelativeCache;
 
   /// Returns [contents] with characters that are meaningful in globs
   /// backslash-escaped.
   static String quote(String contents) =>
       contents.replaceAllMapped(_quoteRegExp, (match) => '\\${match[0]}');
 
   /// Creates a new glob with [pattern].
   ///
   /// Paths matched against the glob are interpreted according to [context]. It
   /// defaults to the system context.
   ///
   /// If [recursive] is true, this glob matches and lists not only the files and
   /// directories it explicitly matches, but anything beneath those as well.
   ///
   /// If [caseSensitive] is true, this glob matches and lists only files whose
   /// case matches that of the characters in the glob. Otherwise, it matches
   /// regardless of case. This defaults to `false` when [context] is Windows and
   /// `true` otherwise.
-  factory Glob(String pattern, {p.Context context, bool recursive: false,
-      bool caseSensitive}) {
+  factory Glob(String pattern,
+      {p.Context context, bool recursive: false, bool caseSensitive}) {
     context ??= p.context;
     caseSensitive ??= context.style == p.Style.windows ? false : true;
     if (recursive) pattern += "{,/**}";
 
     var parser = new Parser(pattern, context, caseSensitive: caseSensitive);
     return new Glob._(pattern, context, parser.parse(), recursive);
   }
 
   Glob._(this.pattern, this.context, this._ast, this.recursive);
 
@@ skipping 64 matching lines @@
     return null;
   }
 
   Iterable<Match> allMatches(String path, [int start = 0]) {
     var match = matchAsPrefix(path, start);
     return match == null ? [] : [match];
   }
 
   String toString() => pattern;
 }