Merge from master

src/vs/base/common/glob.ts

@@ -2,14 +2,13 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
 import * as arrays from 'vs/base/common/arrays';
 import * as strings from 'vs/base/common/strings';
 import * as paths from 'vs/base/common/paths';
 import { LRUCache } from 'vs/base/common/map';
 import { CharCode } from 'vs/base/common/charCode';
-import { TPromise } from 'vs/base/common/winjs.base';
+import { isThenable } from 'vs/base/common/async';
 
 export interface IExpression {
 	[pattern: string]: boolean | SiblingClause | any;
@@ -248,7 +247,7 @@ const T5 = /^([\w\.-]+(\/[\w\.-]+)*)\/?$/; 						   		// something/else
 export type ParsedPattern = (path: string, basename?: string) => boolean;
 
 // The ParsedExpression returns a Promise iff hasSibling returns a Promise.
-export type ParsedExpression = (path: string, basename?: string, hasSibling?: (name: string) => boolean | TPromise<boolean>) => string | TPromise<string> /* the matching pattern */;
+export type ParsedExpression = (path: string, basename?: string, hasSibling?: (name: string) => boolean | Promise<boolean>) => string | null | Promise<string | null> /* the matching pattern */;
 
 export interface IGlobOptions {
 	/**
@@ -258,14 +257,14 @@ export interface IGlobOptions {
 }
 
 interface ParsedStringPattern {
-	(path: string, basename: string): string | TPromise<string> /* the matching pattern */;
+	(path: string, basename: string): string | null | Promise<string | null> /* the matching pattern */;
 	basenames?: string[];
 	patterns?: string[];
 	allBasenames?: string[];
 	allPaths?: string[];
 }
 interface ParsedExpressionPattern {
-	(path: string, basename: string, name: string, hasSibling: (name: string) => boolean | TPromise<boolean>): string | TPromise<string> /* the matching pattern */;
+	(path: string, basename: string, name?: string, hasSibling?: (name: string) => boolean | Promise<boolean>): string | null | Promise<string | null> /* the matching pattern */;
 	requiresSiblings?: boolean;
 	allBasenames?: string[];
 	allPaths?: string[];
@@ -277,7 +276,7 @@ const FALSE = function () {
 	return false;
 };
 
-const NULL = function (): string {
+const NULL = function (): string | null {
 	return null;
 };
 
@@ -305,7 +304,7 @@ function parsePattern(arg1: string | IRelativePattern, options: IGlobOptions): P
 	}
 
 	// Check for Trivias
-	let match: RegExpExecArray;
+	let match: RegExpExecArray | null;
 	if (T1.test(pattern)) { // common pattern: **/*.txt just need endsWith check
 		const base = pattern.substr(4); // '**/*'.length === 4
 		parsedPattern = function (path, basename) {
@@ -342,7 +341,7 @@ function wrapRelativePattern(parsedPattern: ParsedStringPattern, arg2: string |
 			return null;
 		}
 
-		return parsedPattern(paths.normalize(arg2.pathToRelative(arg2.base, path)), basename);
+		return parsedPattern(arg2.pathToRelative(arg2.base, path), basename);
 	};
 }
 
@@ -481,15 +480,15 @@ export function parse(arg1: string | IExpression | IRelativePattern, options: IG
 	return parsedExpression(<IExpression>arg1, options);
 }
 
-export function hasSiblingPromiseFn(siblingsFn?: () => TPromise<string[]>) {
+export function hasSiblingPromiseFn(siblingsFn?: () => Promise<string[]>) {
 	if (!siblingsFn) {
 		return undefined;
 	}
 
-	let siblings: TPromise<Record<string, true>>;
+	let siblings: Promise<Record<string, true>>;
 	return (name: string) => {
 		if (!siblings) {
-			siblings = (siblingsFn() || TPromise.as([]))
+			siblings = (siblingsFn() || Promise.resolve([]))
 				.then(list => list ? listToMap(list) : {});
 		}
 		return siblings.then(map => !!map[name]);
@@ -530,9 +529,9 @@ export function isRelativePattern(obj: any): obj is IRelativePattern {
  */
 export function parseToAsync(expression: IExpression, options?: IGlobOptions): ParsedExpression {
 	const parsedExpression = parse(expression, options);
-	return (path: string, basename?: string, hasSibling?: (name: string) => boolean | TPromise<boolean>): string | TPromise<string> => {
+	return (path: string, basename?: string, hasSibling?: (name: string) => boolean | Promise<boolean>): string | null | Promise<string | null> => {
 		const result = parsedExpression(path, basename, hasSibling);
-		return result instanceof TPromise ? result : TPromise.as(result);
+		return isThenable(result) ? result : Promise.resolve(result);
 	};
 }
 
@@ -554,7 +553,7 @@ function parsedExpression(expression: IExpression, options: IGlobOptions): Parse
 		return NULL;
 	}
 
-	if (!parsedPatterns.some(parsedPattern => (<ParsedExpressionPattern>parsedPattern).requiresSiblings)) {
+	if (!parsedPatterns.some(parsedPattern => !!(<ParsedExpressionPattern>parsedPattern).requiresSiblings)) {
 		if (n === 1) {
 			return <ParsedStringPattern>parsedPatterns[0];
 		}
@@ -584,8 +583,8 @@ function parsedExpression(expression: IExpression, options: IGlobOptions): Parse
 		return resultExpression;
 	}
 
-	const resultExpression: ParsedStringPattern = function (path: string, basename: string, hasSibling?: (name: string) => boolean | TPromise<boolean>) {
-		let name: string;
+	const resultExpression: ParsedStringPattern = function (path: string, basename: string, hasSibling?: (name: string) => boolean | Promise<boolean>) {
+		let name: string | undefined = undefined;
 
 		for (let i = 0, n = parsedPatterns.length; i < n; i++) {
 			// Pattern matches path
@@ -639,14 +638,14 @@ function parseExpressionPattern(pattern: string, value: any, options: IGlobOptio
 	if (value) {
 		const when = (<SiblingClause>value).when;
 		if (typeof when === 'string') {
-			const result: ParsedExpressionPattern = (path: string, basename: string, name: string, hasSibling: (name: string) => boolean | TPromise<boolean>) => {
+			const result: ParsedExpressionPattern = (path: string, basename: string, name: string, hasSibling: (name: string) => boolean | Promise<boolean>) => {
 				if (!hasSibling || !parsedPattern(path, basename)) {
 					return null;
 				}
 
 				const clausePattern = when.replace('$(basename)', name);
 				const matched = hasSibling(clausePattern);
-				return TPromise.is(matched) ?
+				return isThenable(matched) ?
 					matched.then(m => m ? pattern : null) :
 					matched ? pattern : null;
 			};
@@ -665,7 +664,10 @@ function aggregateBasenameMatches(parsedPatterns: (ParsedStringPattern | ParsedE
 		return parsedPatterns;
 	}
 
-	const basenames = basenamePatterns.reduce<string[]>((all, current) => all.concat((<ParsedStringPattern>current).basenames), []);
+	const basenames = basenamePatterns.reduce<string[]>((all, current) => {
+		const basenames = (<ParsedStringPattern>current).basenames;
+		return basenames ? all.concat(basenames) : all;
+	}, <string[]>[]);
 	let patterns: string[];
 	if (result) {
 		patterns = [];
@@ -673,7 +675,10 @@ function aggregateBasenameMatches(parsedPatterns: (ParsedStringPattern | ParsedE
 			patterns.push(result);
 		}
 	} else {
-		patterns = basenamePatterns.reduce((all, current) => all.concat((<ParsedStringPattern>current).patterns), []);
+		patterns = basenamePatterns.reduce((all, current) => {
+			const patterns = (<ParsedStringPattern>current).patterns;
+			return patterns ? all.concat(patterns) : all;
+		}, <string[]>[]);
 	}
 	const aggregate: ParsedStringPattern = function (path, basename) {
 		if (!path) {
@@ -699,4 +704,4 @@ function aggregateBasenameMatches(parsedPatterns: (ParsedStringPattern | ParsedE
 	const aggregatedPatterns = parsedPatterns.filter(parsedPattern => !(<ParsedStringPattern>parsedPattern).basenames);
 	aggregatedPatterns.push(aggregate);
 	return aggregatedPatterns;
-}
+}