diff --git a/extensions/git-extended/src/prView/prProvider.ts b/extensions/git-extended/src/prView/prProvider.ts
index adc63a82ece..a6afd0edaa6 100644
--- a/extensions/git-extended/src/prView/prProvider.ts
+++ b/extensions/git-extended/src/prView/prProvider.ts
@@ -185,13 +185,13 @@ export class PRProvider implements vscode.TreeDataProvider<PRGroupTreeItem | Pul
 							matches = regex.exec(fileChange.patch);
 						}
 
-						return {
+						return [{
 							ranges: ret,
 							actions: actions
-						};
+						}];
 					}
 
-					return null;
+					return [];
 				},
 				provideComments: async (document: vscode.TextDocument, token: vscode.CancellationToken) => {
 					if (document.uri.scheme === 'pr') {
diff --git a/extensions/git-extended/src/review/reviewMode.ts b/extensions/git-extended/src/review/reviewMode.ts
index d10554fcd22..cf043dee64d 100644
--- a/extensions/git-extended/src/review/reviewMode.ts
+++ b/extensions/git-extended/src/review/reviewMode.ts
@@ -177,17 +177,17 @@ export class ReviewMode {
 				if (document.uri.scheme === 'review' || document.uri.scheme === 'file') {
 					let lastLine = document.lineCount;
 					let lastColumn = document.lineAt(lastLine - 1).text.length;
-					return {
+					return [{
 						ranges: [
 							new vscode.Range(1, 1, lastLine, lastColumn)
 						],
 						actions: actions
-					};
+					}];
 				} else {
-					return {
+					return [{
 						ranges: [],
 						actions: []
-					};
+					}];
 				}
 			},
 			provideComments: async (document: vscode.TextDocument, token: vscode.CancellationToken) => {
diff --git a/src/vs/editor/common/modes.ts b/src/vs/editor/common/modes.ts
index 942fd91ec34..b4de6251e5e 100644
--- a/src/vs/editor/common/modes.ts
+++ b/src/vs/editor/common/modes.ts
@@ -976,8 +976,8 @@ export interface CommentThreadChangedEvent {
 
 
 export interface CommentProvider {
-	provideComments(model: model.ITextModel, token: CancellationToken): CommentThread[];
-	provideNewCommentRange(model: model.ITextModel, token: CancellationToken): Promise<NewCommentAction>;
+	provideComments(model: model.ITextModel, token: CancellationToken): Promise<CommentThread[]>;
+	provideNewCommentRange(model: model.ITextModel, token: CancellationToken): Promise<NewCommentAction[]>;
 	provideAllComments(token: CancellationToken): Promise<CommentThread[]>;
 	onDidChangeCommentThreads(): Event<CommentThreadChangedEvent>;
 }
diff --git a/src/vs/monaco.d.ts b/src/vs/monaco.d.ts
index cb42a57a7f5..1a3b887809a 100644
--- a/src/vs/monaco.d.ts
+++ b/src/vs/monaco.d.ts
@@ -5063,8 +5063,8 @@ declare namespace monaco.languages {
 	}
 
 	export interface CommentProvider {
-		provideComments(model: editor.ITextModel, token: CancellationToken): CommentThread[];
-		provideNewCommentRange(model: editor.ITextModel, token: CancellationToken): Promise<NewCommentAction>;
+		provideComments(model: editor.ITextModel, token: CancellationToken): Promise<CommentThread[]>;
+		provideNewCommentRange(model: editor.ITextModel, token: CancellationToken): Promise<NewCommentAction[]>;
 		provideAllComments(token: CancellationToken): Promise<CommentThread[]>;
 		onDidChangeCommentThreads(): IEvent<CommentThreadChangedEvent>;
 	}
diff --git a/src/vs/vscode.proposed.d.ts b/src/vs/vscode.proposed.d.ts
index 501e3f02956..4205f9a5043 100644
--- a/src/vs/vscode.proposed.d.ts
+++ b/src/vs/vscode.proposed.d.ts
@@ -812,7 +812,7 @@ declare module 'vscode' {
 	 */
 	interface CommentProvider {
 		provideComments(document: TextDocument, token: CancellationToken): Promise<CommentThread[]>;
-		provideNewCommentRange(document: TextDocument, token: CancellationToken): Promise<NewCommentAction>;
+		provideNewCommentRange(document: TextDocument, token: CancellationToken): Promise<NewCommentAction[]>;
 		provideAllComments?(token: CancellationToken): Promise<CommentThread[]>;
 		onDidChangeCommentThreads?: Event<CommentThreadChangedEvent>;
 	}
diff --git a/src/vs/workbench/api/electron-browser/mainThreadComments.ts b/src/vs/workbench/api/electron-browser/mainThreadComments.ts
index c684c79bed8..c542fab8669 100644
--- a/src/vs/workbench/api/electron-browser/mainThreadComments.ts
+++ b/src/vs/workbench/api/electron-browser/mainThreadComments.ts
@@ -55,6 +55,18 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 			this.provideNewCommentRange(outerEditor.getModel()).then(newActions => {
 				controller.setNewCommentActions(newActions);
 			});
+
+			_commentService.registerDataProvider({
+				provideAllComments: async (token) => {
+					return await this.provideAllComments();
+				},
+				provideComments: async (model, token) => {
+					return await this.provideComments(model.uri);
+				},
+				provideNewCommentRange: async (model, token) => {
+					return await this.provideNewCommentRange(model);
+				}
+			});
 		});
 	}
 
@@ -92,7 +104,15 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		return editor;
 	}
 
-	async provideComments(resource: URI): Promise<any> {
+	async provideAllComments(): Promise<modes.CommentThread[]> {
+		const result: modes.CommentThread[] = [];
+		for (const handle of keys(this._providers)) {
+			result.push(...await this._proxy.$provideAllComments(handle));
+		}
+		return result;
+	}
+
+	async provideComments(resource: URI): Promise<modes.CommentThread[]> {
 		const result: modes.CommentThread[] = [];
 		for (const handle of keys(this._providers)) {
 			result.push(...await this._proxy.$provideComments(handle, resource));
@@ -104,8 +124,8 @@ export class MainThreadComments extends Disposable implements MainThreadComments
 		const result: modes.NewCommentAction[] = [];
 		for (const handle of keys(this._providers)) {
 			let newCommentRange = await this._proxy.$provideNewCommentRange(handle, model.uri);
-			if (newCommentRange) {
-				result.push(newCommentRange);
+			if (newCommentRange.length > 0) {
+				result.push(...newCommentRange);
 			}
 		}
 		return result;
diff --git a/src/vs/workbench/api/node/extHost.protocol.ts b/src/vs/workbench/api/node/extHost.protocol.ts
index a7f9cbbd692..13799f568bd 100644
--- a/src/vs/workbench/api/node/extHost.protocol.ts
+++ b/src/vs/workbench/api/node/extHost.protocol.ts
@@ -833,7 +833,7 @@ export interface ExtHostProgressShape {
 
 export interface ExtHostCommentsShape {
 	$provideComments(handle: number, document: UriComponents): TPromise<modes.CommentThread[]>;
-	$provideNewCommentRange(handle: number, document: UriComponents): TPromise<modes.NewCommentAction>;
+	$provideNewCommentRange(handle: number, document: UriComponents): TPromise<modes.NewCommentAction[]>;
 	$provideAllComments(handle: number): TPromise<modes.CommentThread[]>;
 }
 
diff --git a/src/vs/workbench/api/node/extHostComments.ts b/src/vs/workbench/api/node/extHostComments.ts
index 7fb835c4aa8..877cdabf96d 100644
--- a/src/vs/workbench/api/node/extHostComments.ts
+++ b/src/vs/workbench/api/node/extHostComments.ts
@@ -87,7 +87,7 @@ export class ExtHostComments implements ExtHostCommentsShape {
 	}
 
 
-	$provideNewCommentRange(handle: number, uri: UriComponents): TPromise<modes.NewCommentAction> {
+	$provideNewCommentRange(handle: number, uri: UriComponents): TPromise<modes.NewCommentAction[]> {
 		const data = this._documents.getDocumentData(URI.revive(uri));
 		if (!data || !data.document) {
 			return TPromise.as(null);
@@ -97,8 +97,7 @@ export class ExtHostComments implements ExtHostCommentsShape {
 			let provider = this._providers.get(handle);
 			return provider.provideNewCommentRange(data.document, token);
 		})
-			.then(newCommentAction => convertNewCommandAction(newCommentAction, this._commandsConverter));
-
+			.then(newCommentActions => newCommentActions.map(newCommentAction => convertNewCommandAction(newCommentAction, this._commandsConverter)));
 	}
 }
 
diff --git a/src/vs/workbench/services/comments/electron-browser/commentService.ts b/src/vs/workbench/services/comments/electron-browser/commentService.ts
index c2188c4c880..8493d4e52d3 100644
--- a/src/vs/workbench/services/comments/electron-browser/commentService.ts
+++ b/src/vs/workbench/services/comments/electron-browser/commentService.ts
@@ -5,11 +5,13 @@
 
 'use strict';
 
-import { CommentThread } from 'vs/editor/common/modes';
+import { CommentThread, CommentProvider, NewCommentAction } from 'vs/editor/common/modes';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { Event, Emitter } from 'vs/base/common/event';
 import { Disposable } from 'vs/base/common/lifecycle';
 import URI from 'vs/base/common/uri';
+import { ITextModel } from 'vs/editor/common/model';
+import { CancellationToken } from 'vs/base/common/cancellation';
 
 export const ICommentService = createDecorator<ICommentService>('commentService');
 
@@ -25,9 +27,10 @@ export interface ICommentService {
 	setComments(resource: URI, commentThreads: CommentThread[]): void;
 	setAllComments(commentsByResource: CommentThread[]): void;
 	removeAllComments(): void;
+	registerDataProvider(commentProvider: CommentProvider): void;
 }
 
-export class CommentService extends Disposable implements ICommentService {
+export class CommentService extends Disposable implements ICommentService, CommentProvider {
 	_serviceBrand: any;
 
 	private readonly _onDidSetResourceCommentThreads: Emitter<IResourceCommentThreadEvent> = this._register(new Emitter<IResourceCommentThreadEvent>());
@@ -36,11 +39,13 @@ export class CommentService extends Disposable implements ICommentService {
 	private readonly _onDidSetAllCommentThreads: Emitter<CommentThread[]> = this._register(new Emitter<CommentThread[]>());
 	readonly onDidSetAllCommentThreads: Event<CommentThread[]> = this._onDidSetAllCommentThreads.event;
 
+	private _commentProvider: CommentProvider;
+
 	constructor() {
 		super();
+		this._commentProvider = null;
 	}
 
-
 	setComments(resource: URI, commentThreads: CommentThread[]): void {
 		this._onDidSetResourceCommentThreads.fire({ resource, commentThreads });
 	}
@@ -52,4 +57,20 @@ export class CommentService extends Disposable implements ICommentService {
 	removeAllComments(): void {
 		this._onDidSetAllCommentThreads.fire([]);
 	}
+
+	registerDataProvider(commentProvider: CommentProvider) {
+		this._commentProvider = commentProvider;
+	}
+
+	async provideComments(model: ITextModel, token: CancellationToken): Promise<CommentThread[]> {
+		return this._commentProvider.provideComments(model, token);
+	}
+
+	async provideNewCommentRange(model: ITextModel, token: CancellationToken): Promise<NewCommentAction[]> {
+		return this._commentProvider.provideNewCommentRange(model, token);
+	}
+
+	async provideAllComments(token: CancellationToken): Promise<CommentThread[]> {
+		return this._commentProvider.provideAllComments(token);
+	}
 }