Fix #136. Memory leak when tree view is refreshed.

Author: rebornix

package-lock.json

@@ -17,6 +17,7 @@ export class PullRequestsTreeDataProvider implements vscode.TreeDataProvider<Tre
 	private _onDidChange = new vscode.EventEmitter<vscode.Uri>();
 	get onDidChange(): vscode.Event<vscode.Uri> { return this._onDidChange.event; }
 	private _disposables: vscode.Disposable[];
+	private _childrenDisposables: vscode.Disposable[];
 
 	constructor(
 		private _configuration: Configuration,
@@ -39,6 +40,7 @@ export class PullRequestsTreeDataProvider implements vscode.TreeDataProvider<Tre
 		this._disposables.push(this._configuration.onDidChange(e => {
 			this._onDidChangeTreeData.fire();
 		}));
+		this._childrenDisposables = [];
 	}
 
 	getTreeItem(element: TreeNode): vscode.TreeItem {
@@ -47,13 +49,20 @@ export class PullRequestsTreeDataProvider implements vscode.TreeDataProvider<Tre
 
 	async getChildren(element?: TreeNode): Promise<TreeNode[]> {
 		if (!element) {
-			return Promise.resolve([
+			if (this._childrenDisposables && this._childrenDisposables.length) {
+				this._childrenDisposables.forEach(dispose => dispose.dispose());
+			}
+
+			let result = [
 				new CategoryTreeNode(this._prManager, this._repository, PRType.LocalPullRequest),
 				new CategoryTreeNode(this._prManager, this._repository, PRType.RequestReview),
 				new CategoryTreeNode(this._prManager, this._repository, PRType.AssignedToMe),
 				new CategoryTreeNode(this._prManager, this._repository, PRType.Mine),
 				new CategoryTreeNode(this._prManager, this._repository, PRType.All)
-			]);
+			];
+
+			this._childrenDisposables = result;
+			return Promise.resolve(result);
 		}
 		if (!this._repository.remotes || !this._repository.remotes.length) {
 			return Promise.resolve([new PRCategoryActionNode(PRCategoryActionType.Empty)]);

src/view/prsTreeDataProvider.ts

@@ -129,9 +129,13 @@ export class CategoryTreeNode extends TreeNode implements vscode.TreeItem {
 				nodes.push(new PRCategoryActionNode(PRCategoryActionType.More, this));
 			}
 
+			this.childrenDisposables = nodes;
 			return nodes;
 		} else {
-			return [new PRCategoryActionNode(PRCategoryActionType.Empty)];
+			let result = [new PRCategoryActionNode(PRCategoryActionType.Empty)];
+
+			this.childrenDisposables = result;
+			return result;
 		}
 	}
 

src/view/treeNodes/categoryNode.ts

@@ -77,5 +77,4 @@ export class FileChangeNode extends TreeNode implements vscode.TreeItem {
 	getTreeItem(): vscode.TreeItem {
 		return this;
 	}
-
 }

src/view/treeNodes/fileChangeNode.ts

@@ -20,8 +20,9 @@ import { FileChangeNode } from './fileChangeNode';
 import { TreeNode } from './treeNode';
 
 export class PRNode extends TreeNode {
-	private richContentChanges: RichFileChange[];
-	private commentsCache: Map<String, Comment[]>;
+	private _richContentChanges: RichFileChange[];
+	private _commentsCache: Map<String, Comment[]>;
+	private _documentCommentsProvider: vscode.Disposable;
 
 	constructor(
 		private _prManager: IPullRequestManager,
@@ -30,16 +31,25 @@ export class PRNode extends TreeNode {
 		private _isLocal: boolean
 	) {
 		super();
+		this._documentCommentsProvider = null;
 	}
 
 	async getChildren(): Promise<TreeNode[]> {
 		try {
+			if (this._documentCommentsProvider) {
+				this._documentCommentsProvider.dispose();
+			}
+
+			if (this.childrenDisposables && this.childrenDisposables.length) {
+				this.childrenDisposables.forEach(dp => dp.dispose());
+			}
+
 			const comments = await this._prManager.getPullRequestComments(this.pullRequestModel);
 			const data = await this._prManager.getPullRequestChangedFiles(this.pullRequestModel);
 			await this._prManager.fullfillPullRequestCommitInfo(this.pullRequestModel);
-			this.richContentChanges = await parseDiff(data, this.repository, this.pullRequestModel.base.sha);
-			this.commentsCache = new Map<String, Comment[]>();
-			let fileChanges = this.richContentChanges.map(change => {
+			this._richContentChanges = await parseDiff(data, this.repository, this.pullRequestModel.base.sha);
+			this._commentsCache = new Map<String, Comment[]>();
+			let fileChanges = this._richContentChanges.map(change => {
 				let fileInRepo = path.resolve(this.repository.path, change.fileName);
 				let changedItem = new FileChangeNode(
 					this.pullRequestModel,
@@ -51,22 +61,26 @@ export class PRNode extends TreeNode {
 					change.diffHunks,
 					comments.filter(comment => comment.path === change.fileName && comment.position !== null)
 				);
-				this.commentsCache.set(change.fileName, changedItem.comments);
+				this._commentsCache.set(change.fileName, changedItem.comments);
 				return changedItem;
 			});
 
 			const _onDidChangeCommentThreads = new vscode.EventEmitter<vscode.CommentThreadChangedEvent>();
-			vscode.workspace.registerDocumentCommentProvider({
+
+			this._documentCommentsProvider = vscode.workspace.registerDocumentCommentProvider({
 				onDidChangeCommentThreads: _onDidChangeCommentThreads.event,
 				provideDocumentComments: this.provideDocumentComments.bind(this),
 				createNewCommentThread: this.createNewCommentThread.bind(this),
 				replyToCommentThread: this.replyToCommentThread.bind(this)
 			});
 
-			return [new DescriptionNode('Description', {
+			let result = [new DescriptionNode('Description', {
 				light: Resource.icons.light.Description,
 				dark: Resource.icons.dark.Description
 			}, this.pullRequestModel), ...fileChanges];
+
+			this.childrenDisposables = result;
+			return result;
 		} catch (e) {
 			Logger.appendLine(e);
 		}
@@ -88,7 +102,7 @@ export class PRNode extends TreeNode {
 			let uri = document.uri;
 			let params = JSON.parse(uri.query);
 
-			let fileChange = this.richContentChanges.find(change => change.fileName === params.fileName);
+		let fileChange = this._richContentChanges.find(change => change.fileName === params.fileName);
 
 			if (!fileChange) {
 				return null;
@@ -144,7 +158,7 @@ export class PRNode extends TreeNode {
 		if (document.uri.scheme === 'pr') {
 			let params = JSON.parse(document.uri.query);
 			let isBase = params.base;
-			let fileChange = this.richContentChanges.find(change => change.fileName === params.fileName);
+			let fileChange = this._richContentChanges.find(change => change.fileName === params.fileName);
 			if (!fileChange) {
 				return null;
 			}
@@ -168,7 +182,7 @@ export class PRNode extends TreeNode {
 				commentingRanges.push(new vscode.Range(startingLine, 0, startingLine + length, 0));
 			}
 
-			let matchingComments = this.commentsCache.get(fileChange.fileName);
+			let matchingComments = this._commentsCache.get(fileChange.fileName);
 
 			if (!matchingComments || !matchingComments.length) {
 				return {
@@ -218,4 +232,12 @@ export class PRNode extends TreeNode {
 
 		return null;
 	}
+
+	dispose(): void {
+		super.dispose();
+
+		if (this._documentCommentsProvider) {
+			this._documentCommentsProvider.dispose();
+		}
+	}
 }

src/view/treeNodes/pullRequestNode.ts

@@ -5,11 +5,18 @@
 
 import * as vscode from 'vscode';
 
-export abstract class TreeNode {
+export abstract class TreeNode implements vscode.Disposable {
+	childrenDisposables: vscode.Disposable[];
+
 	constructor() { }
 	abstract getTreeItem(): vscode.TreeItem;
 
 	async getChildren(): Promise<TreeNode[]> {
 		return [];
 	}
+	dispose(): void {
+		if (this.childrenDisposables && this.childrenDisposables) {
+			this.childrenDisposables.forEach(dispose => dispose.dispose());
+		}
+	}
 }