Removes redundant methods to sub-providers

Author: eamodio

src/commands/git/remote.ts

@@ -328,11 +328,9 @@ export class RemoteGitCommand extends QuickCommand<State> {
 
 			endSteps(state);
 
-			const remote = await state.repo.addRemote(
-				state.name,
-				state.url,
-				state.flags.includes('-f') ? { fetch: true } : undefined,
-			);
+			const remote = await state.repo.git
+				.remotes()
+				.addRemoteWithResult?.(state.name, state.url, state.flags.includes('-f') ? { fetch: true } : undefined);
 			if (state.reveal !== false) {
 				void reveal(remote, {
 					focus: true,

src/commands/git/worktree.ts

@@ -522,10 +522,12 @@ export class WorktreeGitCommand extends QuickCommand<State> {
 			let worktree: GitWorktree | undefined;
 			try {
 				if (state.addRemote != null) {
-					await state.repo.addRemote(state.addRemote.name, state.addRemote.url, { fetch: true });
+					await state.repo.git
+						.remotes()
+						.addRemoteWithResult?.(state.addRemote.name, state.addRemote.url, { fetch: true });
 				}
 
-				worktree = await state.repo.createWorktree(uri, {
+				worktree = await state.repo.git.worktrees()?.createWorktreeWithResult(uri.fsPath, {
 					commitish: state.reference?.name,
 					createBranch: state.flags.includes('-b') ? state.createBranch : undefined,
 					detach: state.flags.includes('--detach'),

src/env/node/git/sub-providers/patch.ts

@@ -17,7 +17,7 @@ import type { GitCommit } from '../../../../git/models/commit';
 import { log } from '../../../../system/decorators/log';
 import { Logger } from '../../../../system/logger';
 import { getLogScope } from '../../../../system/logger.scope';
-import { joinPaths, normalizePath } from '../../../../system/path';
+import { joinPaths } from '../../../../system/path';
 import type { Git } from '../git';
 import type { LocalGitProvider } from '../localGitProvider';
 
@@ -94,10 +94,23 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 			}
 
 			try {
-				await this.provider.worktrees.createWorktree(repoPath, options.createWorktreePath, {
-					commitish: options?.branchName != null && branchExists ? options.branchName : currentBranch?.name,
-					createBranch: shouldCreate ? options.branchName : undefined,
-				});
+				const worktree = await this.provider.worktrees.createWorktreeWithResult(
+					repoPath,
+					options.createWorktreePath,
+					{
+						commitish:
+							options?.branchName != null && branchExists ? options.branchName : currentBranch?.name,
+						createBranch: shouldCreate ? options.branchName : undefined,
+					},
+				);
+				if (worktree == null) {
+					throw new ApplyPatchCommitError(
+						ApplyPatchCommitErrorReason.CreateWorktreeFailed,
+						'Unable to apply patch; failed creating worktree',
+					);
+				}
+
+				targetPath = worktree.uri.fsPath;
 			} catch (ex) {
 				Logger.error(ex, scope);
 				throw new ApplyPatchCommitError(
@@ -108,19 +121,6 @@ export class PatchGitSubProvider implements GitPatchSubProvider {
 					ex,
 				);
 			}
-
-			const worktree = await this.provider.worktrees?.getWorktree(
-				repoPath,
-				w => normalizePath(w.uri.fsPath) === normalizePath(options.createWorktreePath!),
-			);
-			if (worktree == null) {
-				throw new ApplyPatchCommitError(
-					ApplyPatchCommitErrorReason.CreateWorktreeFailed,
-					'Unable to apply patch; failed creating worktree',
-				);
-			}
-
-			targetPath = worktree.uri.fsPath;
 		}
 
 		if (options?.branchName != null && currentBranch?.name !== options.branchName) {

src/env/node/git/sub-providers/remotes.ts

@@ -82,6 +82,19 @@ export class RemotesGitSubProvider extends RemotesGitProviderBase implements Git
 		this.container.events.fire('git:cache:reset', { repoPath: repoPath, caches: ['remotes'] });
 	}
 
+	@gate()
+	@log()
+	async addRemoteWithResult(
+		repoPath: string,
+		name: string,
+		url: string,
+		options?: { fetch?: boolean },
+	): Promise<GitRemote | undefined> {
+		await this.addRemote(repoPath, name, url, options);
+		const [remote] = await this.getRemotes(repoPath, { filter: r => r.url === url });
+		return remote;
+	}
+
 	@gate()
 	@log()
 	async pruneRemote(repoPath: string, name: string): Promise<void> {

src/env/node/git/sub-providers/worktrees.ts

@@ -37,15 +37,15 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 		repoPath: string,
 		path: string,
 		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
-	) {
+	): Promise<void> {
 		const scope = getLogScope();
 
 		try {
 			await this.git.worktree__add(repoPath, path, options);
-			this.container.events.fire('git:cache:reset', { repoPath: repoPath, caches: ['worktrees'] });
-			if (options?.createBranch) {
-				this.container.events.fire('git:cache:reset', { repoPath: repoPath, caches: ['branches'] });
-			}
+			this.container.events.fire('git:cache:reset', {
+				repoPath: repoPath,
+				caches: options?.createBranch ? ['branches', 'worktrees'] : ['worktrees'],
+			});
 		} catch (ex) {
 			Logger.error(ex, scope);
 
@@ -63,6 +63,16 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 		}
 	}
 
+	async createWorktreeWithResult(
+		repoPath: string,
+		path: string,
+		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+	): Promise<GitWorktree | undefined> {
+		await this.createWorktree(repoPath, path, options);
+		const normalized = normalizePath(path);
+		return this.getWorktree(repoPath, w => normalizePath(w.uri.fsPath) === normalized);
+	}
+
 	@log()
 	async getWorktree(repoPath: string, predicate: (w: GitWorktree) => boolean): Promise<GitWorktree | undefined> {
 		return (await this.getWorktrees(repoPath)).find(predicate);

src/git/gitProvider.ts

@@ -482,6 +482,12 @@ export interface GitRemotesSubProvider {
 		cancellation?: CancellationToken,
 	): Promise<GitRemote<RemoteProvider> | undefined>;
 	addRemote?(repoPath: string, name: string, url: string, options?: { fetch?: boolean }): Promise<void>;
+	addRemoteWithResult?(
+		repoPath: string,
+		name: string,
+		url: string,
+		options?: { fetch?: boolean },
+	): Promise<GitRemote | undefined>;
 	pruneRemote?(repoPath: string, name: string): Promise<void>;
 	removeRemote?(repoPath: string, name: string): Promise<void>;
 	setRemoteAsDefault(repoPath: string, name: string, value?: boolean): Promise<void>;
@@ -546,6 +552,11 @@ export interface GitWorktreesSubProvider {
 		path: string,
 		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
 	): Promise<void>;
+	createWorktreeWithResult(
+		repoPath: string,
+		path: string,
+		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+	): Promise<GitWorktree | undefined>;
 	getWorktree(repoPath: string, predicate: (w: GitWorktree) => boolean): Promise<GitWorktree | undefined>;
 	getWorktrees(repoPath: string): Promise<GitWorktree[]>;
 	getWorktreesDefaultUri(repoPath: string): Promise<Uri | undefined>;

src/git/models/pullRequest.ts

@@ -400,7 +400,9 @@ export async function ensurePullRequestRemote(
 	);
 
 	if (result === confirm) {
-		await repo.addRemote(identity.provider.repoDomain, identity.remote.url, { fetch: true });
+		await repo.git
+			.remotes()
+			.addRemoteWithResult?.(identity.provider.repoDomain, identity.remote.url, { fetch: true });
 		return true;
 	}
 

src/git/models/repository.ts

@@ -28,8 +28,6 @@ import type { GitBranch } from './branch';
 import { getBranchNameWithoutRemote, getNameWithoutRemote, getRemoteNameFromBranchName } from './branch.utils';
 import type { GitBranchReference, GitReference } from './reference';
 import { isBranchReference } from './reference.utils';
-import type { GitRemote } from './remote';
-import type { GitWorktree } from './worktree';
 
 type GitProviderRepoKeys = keyof GitRepositoryProvider | 'supports';
 
@@ -543,14 +541,6 @@ export class Repository implements Disposable {
 		return this.container.git.access(feature, this.uri);
 	}
 
-	// TODO: Can we remove this -- since no callers use the return value (though maybe they need that await?)
-	@log()
-	async addRemote(name: string, url: string, options?: { fetch?: boolean }): Promise<GitRemote | undefined> {
-		await this.git.remotes().addRemote?.(name, url, options);
-		const [remote] = await this.git.remotes().getRemotes({ filter: r => r.url === url });
-		return remote;
-	}
-
 	@log()
 	branchDelete(branches: GitBranchReference | GitBranchReference[], options?: { force?: boolean; remote?: boolean }) {
 		if (!Array.isArray(branches)) {
@@ -687,20 +677,6 @@ export class Repository implements Disposable {
 		return this._lastFetched ?? 0;
 	}
 
-	// TODO: Move to GitProviderService?
-	@log()
-	async createWorktree(
-		uri: Uri,
-		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
-	): Promise<GitWorktree | undefined> {
-		const worktrees = this.git.worktrees();
-		if (worktrees == null) return undefined;
-
-		await worktrees.createWorktree(uri.fsPath, options);
-		const url = uri.toString();
-		return worktrees.getWorktree(w => w.uri.toString() === url);
-	}
-
 	@log()
 	merge(...args: string[]) {
 		void this.runTerminalCommand('merge', ...args);

src/uris/deepLinks/deepLinkService.ts

@@ -924,7 +924,7 @@ export class DeepLinkService implements Disposable {
 
 						if (remoteName) {
 							try {
-								await repo.addRemote(remoteName, remoteUrl, { fetch: true });
+								await repo.git.remotes().addRemoteWithResult?.(remoteName, remoteUrl, { fetch: true });
 							} catch {
 								action = DeepLinkServiceAction.DeepLinkErrored;
 								message = 'Failed to add remote.';
@@ -953,7 +953,9 @@ export class DeepLinkService implements Disposable {
 
 						if (secondaryRemoteName) {
 							try {
-								await repo.addRemote(secondaryRemoteName, secondaryRemoteUrl, { fetch: true });
+								await repo.git
+									.remotes()
+									.addRemoteWithResult?.(secondaryRemoteName, secondaryRemoteUrl, { fetch: true });
 							} catch {
 								action = DeepLinkServiceAction.DeepLinkErrored;
 								message = 'Failed to add remote.';