Addressed #53673: Cake Extension for VS Code no longer fully working in 1.25.0 release

src/vs/workbench/api/electron-browser/mainThreadTask.ts

@@ -11,6 +11,7 @@ import * as Objects from 'vs/base/common/objects';
 import { TPromise } from 'vs/base/common/winjs.base';
 import * as Types from 'vs/base/common/types';
 import * as Platform from 'vs/base/common/platform';
+import { IStringDictionary } from 'vs/base/common/collections';
 
 import { IWorkspaceContextService, IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 
@@ -386,8 +387,8 @@ export class MainThreadTask implements MainThreadTaskShape {
 
 	public $registerTaskProvider(handle: number): TPromise<void> {
 		this._taskService.registerTaskProvider(handle, {
-			provideTasks: () => {
-				return this._proxy.$provideTasks(handle).then((value) => {
+			provideTasks: (validTypes: IStringDictionary<boolean>) => {
+				return this._proxy.$provideTasks(handle, validTypes).then((value) => {
 					let tasks: Task[] = [];
 					for (let task of value.tasks) {
 						let taskTransfer = task._source as any as ExtensionTaskSourceTransfer;

src/vs/workbench/api/node/extHost.protocol.ts

@@ -878,7 +878,7 @@ export interface ExtHostSCMShape {
 }
 
 export interface ExtHostTaskShape {
-	$provideTasks(handle: number): TPromise<TaskSet>;
+	$provideTasks(handle: number, validTypes: { [key: string]: boolean; }): TPromise<TaskSet>;
 	$onDidStartTask(execution: TaskExecutionDTO): void;
 	$onDidStartTaskProcess(value: TaskProcessStartedDTO): void;
 	$onDidEndTaskProcess(value: TaskProcessEndedDTO): void;

src/vs/workbench/api/node/extHostTask.ts

@@ -860,15 +860,23 @@ export class ExtHostTask implements ExtHostTaskShape {
 		}
 	}
 
-	public $provideTasks(handle: number): TPromise<tasks.TaskSet> {
+	public $provideTasks(handle: number, validTypes: { [key: string]: boolean; }): TPromise<tasks.TaskSet> {
 		let handler = this._handlers.get(handle);
 		if (!handler) {
 			return TPromise.wrapError<tasks.TaskSet>(new Error('no handler found'));
 		}
 		return asWinJsPromise(token => handler.provider.provideTasks(token)).then(value => {
+			let sanitized: vscode.Task[] = [];
+			for (let task of value) {
+				if (task.definition && validTypes[task.definition.type] === true) {
+					sanitized.push(task);
+				} else {
+					console.error(`Dropping task [${task.source}, ${task.name}]. Its type is not known to the system.`);
+				}
+			}
 			let workspaceFolders = this._workspaceService.getWorkspaceFolders();
 			return {
-				tasks: Tasks.from(value, workspaceFolders && workspaceFolders.length > 0 ? workspaceFolders[0] : undefined, handler.extension),
+				tasks: Tasks.from(sanitized, workspaceFolders && workspaceFolders.length > 0 ? workspaceFolders[0] : undefined, handler.extension),
 				extension: handler.extension
 			};
 		});

src/vs/workbench/parts/tasks/common/taskService.ts

@@ -13,13 +13,14 @@ import { createDecorator } from 'vs/platform/instantiation/common/instantiation'
 import { IWorkspaceFolder } from 'vs/platform/workspace/common/workspace';
 import { Task, ContributedTask, CustomTask, TaskSet, TaskSorter, TaskEvent, TaskIdentifier } from 'vs/workbench/parts/tasks/common/tasks';
 import { ITaskSummary, TaskTerminateResponse, TaskSystemInfo } from 'vs/workbench/parts/tasks/common/taskSystem';
+import { IStringDictionary } from 'vs/base/common/collections';
 
 export { ITaskSummary, Task, TaskTerminateResponse };
 
 export const ITaskService = createDecorator<ITaskService>('taskService');
 
 export interface ITaskProvider {
-	provideTasks(): TPromise<TaskSet>;
+	provideTasks(validTypes: IStringDictionary<boolean>): TPromise<TaskSet>;
 }
 
 export interface RunOptions {

src/vs/workbench/parts/tasks/electron-browser/task.contribution.ts

@@ -1298,7 +1298,9 @@ class TaskService implements ITaskService {
 	}
 
 	private getGroupedTasks(): TPromise<TaskMap> {
-		return this.extensionService.activateByEvent('onCommand:workbench.action.tasks.runTask').then(() => {
+		return TPromise.join([this.extensionService.activateByEvent('onCommand:workbench.action.tasks.runTask'), TaskDefinitionRegistry.onReady()]).then(() => {
+			let validTypes: IStringDictionary<boolean> = Object.create(null);
+			TaskDefinitionRegistry.all().forEach(definition => validTypes[definition.taskType] = true);
 			return new TPromise<TaskSet[]>((resolve, reject) => {
 				let result: TaskSet[] = [];
 				let counter: number = 0;
@@ -1327,7 +1329,7 @@ class TaskService implements ITaskService {
 				if (this.schemaVersion === JsonSchemaVersion.V2_0_0 && this._providers.size > 0) {
 					this._providers.forEach((provider) => {
 						counter++;
-						provider.provideTasks().done(done, error);
+						provider.provideTasks(validTypes).done(done, error);
 					});
 				} else {
 					resolve(result);
@@ -2485,6 +2487,7 @@ let schema: IJSONSchema = {
 
 import schemaVersion1 from './jsonSchema_v1';
 import schemaVersion2 from './jsonSchema_v2';
+import { TaskDefinitionRegistry } from 'vs/workbench/parts/tasks/common/taskDefinitionRegistry';
 schema.definitions = {
 	...schemaVersion1.definitions,
 	...schemaVersion2.definitions,