Merge from master

src/vs/editor/contrib/codeAction/codeAction.ts

@@ -3,11 +3,10 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { flatten, isFalsyOrEmpty, mergeSort } from 'vs/base/common/arrays';
-import { asWinJsPromise } from 'vs/base/common/async';
+import { flatten, mergeSort, isNonEmptyArray } from 'vs/base/common/arrays';
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { illegalArgument, isPromiseCanceledError, onUnexpectedExternalError } from 'vs/base/common/errors';
-import URI from 'vs/base/common/uri';
+import { URI } from 'vs/base/common/uri';
 import { registerLanguageCommand } from 'vs/editor/browser/editorExtensions';
 import { Range } from 'vs/editor/common/core/range';
 import { Selection } from 'vs/editor/common/core/selection';
@@ -22,21 +21,43 @@ export function getCodeActions(model: ITextModel, rangeOrSelection: Range | Sele
 		trigger: trigger && trigger.type === 'manual' ? CodeActionTriggerKind.Manual : CodeActionTriggerKind.Automatic
 	};
 
-	const promises = CodeActionProviderRegistry.all(model).map(support => {
-		return asWinJsPromise(token => support.provideCodeActions(model, rangeOrSelection, codeActionContext, token)).then(providedCodeActions => {
-			if (!Array.isArray(providedCodeActions)) {
-				return [];
-			}
-			return providedCodeActions.filter(action => isValidAction(trigger && trigger.filter, action));
-		}, (err): CodeAction[] => {
-			if (isPromiseCanceledError(err)) {
-				throw err;
+	const promises = CodeActionProviderRegistry.all(model)
+		.filter(provider => {
+			if (!provider.providedCodeActionKinds) {
+				return true;
 			}
 
-			onUnexpectedExternalError(err);
-			return [];
+			// Avoid calling providers that we know will not return code actions of interest
+			return provider.providedCodeActionKinds.some(providedKind => {
+				// Filter out actions by kind
+				// The provided kind can be either a subset of a superset of the filtered kind
+				if (trigger && trigger.filter && trigger.filter.kind && !(trigger.filter.kind.contains(providedKind) || new CodeActionKind(providedKind).contains(trigger.filter.kind.value))) {
+					return false;
+				}
+
+				// Don't return source actions unless they are explicitly requested
+				if (trigger && CodeActionKind.Source.contains(providedKind) && (!trigger.filter || !trigger.filter.includeSourceActions)) {
+					return false;
+				}
+
+				return true;
+			});
+		})
+		.map(support => {
+			return Promise.resolve(support.provideCodeActions(model, rangeOrSelection, codeActionContext, token)).then(providedCodeActions => {
+				if (!Array.isArray(providedCodeActions)) {
+					return [];
+				}
+				return providedCodeActions.filter(action => isValidAction(trigger && trigger.filter, action));
+			}, (err): CodeAction[] => {
+				if (isPromiseCanceledError(err)) {
+					throw err;
+				}
+
+				onUnexpectedExternalError(err);
+				return [];
+			});
 		});
-	});
 
 	return Promise.all(promises)
 		.then(flatten)
@@ -44,17 +65,17 @@ export function getCodeActions(model: ITextModel, rangeOrSelection: Range | Sele
 }
 
 function isValidAction(filter: CodeActionFilter | undefined, action: CodeAction): boolean {
-	if (!action) {
-		return false;
-	}
+	return action && isValidActionKind(filter, action.kind);
+}
 
+function isValidActionKind(filter: CodeActionFilter | undefined, kind: string | undefined): boolean {
 	// Filter out actions by kind
-	if (filter && filter.kind && (!action.kind || !filter.kind.contains(action.kind))) {
+	if (filter && filter.kind && (!kind || !filter.kind.contains(kind))) {
 		return false;
 	}
 
 	// Don't return source actions unless they are explicitly requested
-	if (action.kind && CodeActionKind.Source.contains(action.kind) && (!filter || !filter.includeSourceActions)) {
+	if (kind && CodeActionKind.Source.contains(kind) && (!filter || !filter.includeSourceActions)) {
 		return false;
 	}
 
@@ -62,15 +83,13 @@ function isValidAction(filter: CodeActionFilter | undefined, action: CodeAction)
 }
 
 function codeActionsComparator(a: CodeAction, b: CodeAction): number {
-	const aHasDiags = !isFalsyOrEmpty(a.diagnostics);
-	const bHasDiags = !isFalsyOrEmpty(b.diagnostics);
-	if (aHasDiags) {
-		if (bHasDiags) {
+	if (isNonEmptyArray(a.diagnostics)) {
+		if (isNonEmptyArray(b.diagnostics)) {
 			return a.diagnostics[0].message.localeCompare(b.diagnostics[0].message);
 		} else {
 			return -1;
 		}
-	} else if (bHasDiags) {
+	} else if (isNonEmptyArray(b.diagnostics)) {
 		return 1;
 	} else {
 		return 0;	// both have no diagnostics