safe delete branch

# Conflicts:
#	src/env/node/git/git.ts

Author: sergiolms

src/env/node/git/git.ts

@@ -1622,7 +1622,12 @@ export class Git {
 	async rev_list(
 		repoPath: string,
 		ref: string,
-		options?: { all?: boolean; maxParents?: number; since?: string },
+		options?: {
+			all?: boolean;
+			maxParents?: number;
+			maxResults?: number;
+            since?: string;
+		},
 	): Promise<string[] | undefined> {
 		const params = ['rev-list'];
 		if (options?.all) {
@@ -1633,6 +1638,10 @@ export class Git {
 			params.push(`--max-parents=${options.maxParents}`);
 		}
 
+		if (options?.maxResults != null) {
+			params.push(`-n ${options.maxResults}`);
+		}
+
 		if (options?.since) {
 			params.push(`--since="${options.since}"`, '--date-order');
 		}
@@ -1902,6 +1911,10 @@ export class Git {
 		return data.length === 0 ? undefined : data.trim();
 	}
 
+	async update_ref(repoPath: string, ...args: string[]): Promise<void> {
+		await this.git<string>({ cwd: repoPath }, 'update-ref', ...args);
+	}
+
 	show(
 		repoPath: string,
 		options?: { cancellation?: CancellationToken; configs?: readonly string[] },

src/env/node/git/localGitProvider.ts

@@ -1298,8 +1298,6 @@ export class LocalGitProvider implements GitProvider, Disposable {
 				args.push('--force');
 			}
 
-			await this.git.branch(repoPath, ...args, ...branches.map((b: GitBranchReference) => b.ref));
-
 			if (options.remote) {
 				const trackingBranches = localBranches.filter(b => b.upstream != null);
 				if (trackingBranches.length !== 0) {
@@ -1308,17 +1306,43 @@ export class LocalGitProvider implements GitProvider, Disposable {
 					);
 
 					for (const [remote, branches] of branchesByOrigin.entries()) {
-						await this.git.push(repoPath, {
-							delete: {
-								remote: remote,
-								branches: branches.map(b => getBranchNameWithoutRemote(b.upstream!.name)),
-							},
+						const remoteCommitByBranch: Map<string, string> = {};
+						branches.forEach(async b => {
+							remoteCommit = await this.git.rev_list(repoPath, `refs/remotes/${remote}/${b.ref}`, {
+								maxResults: 1,
+							});
+							remoteCommitByBranch[b.ref] = remoteCommit;
 						});
+
+						await this.git.branch(
+							repoPath,
+							'--delete',
+							'--remotes',
+							...branches.map((b: GitBranchReference) => `${remote}/${b.ref}`),
+						);
+
+						try {
+							await this.git.branch(repoPath, ...args, ...branches.map((b: GitBranchReference) => b.ref));
+							await this.git.push(repoPath, {
+								delete: {
+									remote: remote,
+									branches: branches.map(b => getBranchNameWithoutRemote(b.upstream!.name)),
+								},
+							});
+						} catch (ex) {
+							// If it fails, restore the remote branches
+							remoteCommitByBranch.forEach(async (branch, commit) => {
+								await this.git.update_ref(repoPath, `refs/remotes/${remote}/${branch}`, commit);
+								await this.git.branch__set_upstream(repoPath, branch, remote, branch);
+							});
+							throw ex;
+						}
 					}
 				}
 			}
 		}
 
+		const remoteBranches = branches.filter((b: GitBranchReference) => b.remote);
 		if (remoteBranches.length !== 0) {
 			const branchesByOrigin = groupByMap(remoteBranches, b => getRemoteNameFromBranchName(b.name));