Rewrites & optimizes Git execution & log parsing

 - Adds strongly typed parser interfaces and unified logging format
 - Replaces legacy string-based log parsing with structured parsers
 - Adds streaming support for large git log outputs (not fully realized yet)
 - Consolidates duplicate parser implementations into shared utilities
 - Consolidates revision resolution / revision navigation logic
 - Improves handling of renames, copies, and deleted files
Adds `gitlens.advanced.commits.delayLoadingFileDetails` setting to delay loading file details until required
Improves `diffWith` command handling & lables especially w/ comparisons

Author: eamodio

package.json

@@ -5247,9 +5247,12 @@
 						"scope": "window",
 						"order": 110
 					},
-					"gitlens.advanced.useSymmetricDifferenceNotation": {
-						"deprecationMessage": "Deprecated. This setting is no longer used",
-						"markdownDescription": "Deprecated. This setting is no longer used"
+					"gitlens.advanced.commits.delayLoadingFileDetails": {
+						"type": "boolean",
+						"default": false,
+						"markdownDescription": "Specifies whether to delay loading commit file details until required. This can improve performance when opening repositories with large histories, but causes more incremental Git calls",
+						"scope": "window",
+						"order": 120
 					}
 				}
 			},

src/commands/browseRepoAtRevision.ts

@@ -56,12 +56,13 @@ export class BrowseRepoAtRevisionCommand extends ActiveEditorCommand {
 			}
 
 			let gitUri = await GitUri.fromUri(uri);
-			if (gitUri.sha == null) return;
+			if (gitUri.sha == null) throw new Error('No SHA for Uri');
 
-			const sha = args?.before
-				? await this.container.git.refs(gitUri.repoPath!).resolveReference(`${gitUri.sha}^`)
-				: gitUri.sha;
-			uri = this.container.git.getRevisionUri(gitUri.repoPath!, sha, gitUri.repoPath!);
+			const repo = this.container.git.getRepository(gitUri.repoPath!);
+			if (repo == null) throw new Error('No repository for Uri');
+
+			const sha = args?.before ? (await repo.git.revision().resolveRevision(`${gitUri.sha}^`)).sha : gitUri.sha;
+			uri = repo.git.getRevisionUri(sha, gitUri.repoPath!);
 			gitUri = GitUri.fromRevisionUri(uri);
 
 			openWorkspace(uri, {

src/commands/diffWith.ts

@@ -5,13 +5,14 @@ import type { Container } from '../container';
 import type { GitCommit } from '../git/models/commit';
 import { isCommit } from '../git/models/commit';
 import { deletedOrMissing } from '../git/models/revision';
-import { isShaWithOptionalRevisionSuffix, isUncommitted, shortenRevision } from '../git/utils/revision.utils';
+import { isShaWithParentSuffix, isUncommitted, shortenRevision } from '../git/utils/revision.utils';
 import { showGenericErrorMessage } from '../messages';
 import { command } from '../system/-webview/command';
 import { openDiffEditor } from '../system/-webview/vscode/editors';
 import { createMarkdownCommandLink } from '../system/commands';
 import { Logger } from '../system/logger';
 import { basename } from '../system/path';
+import { getSettledValue } from '../system/promise';
 import { GlCommandBase } from './commandBase';
 
 export interface DiffWithCommandArgsRevision {
@@ -25,6 +26,7 @@ export interface DiffWithCommandArgs {
 	rhs: DiffWithCommandArgsRevision;
 	repoPath: string | undefined;
 
+	fromComparison?: boolean;
 	line?: number;
 	showOptions?: TextDocumentShowOptions;
 }
@@ -45,28 +47,16 @@ export class DiffWithCommand extends GlCommandBase {
 			if (commit.isUncommitted) {
 				args = {
 					repoPath: commit.repoPath,
-					lhs: {
-						sha: 'HEAD',
-						uri: commit.file.uri,
-					},
-					rhs: {
-						sha: '',
-						uri: commit.file.uri,
-					},
+					lhs: { sha: 'HEAD', uri: commit.file.uri },
+					rhs: { sha: '', uri: commit.file.uri },
 					line: line,
 				};
 			} else {
 				args = {
 					repoPath: commit.repoPath,
-					lhs: {
-						// Don't need to worry about verifying the previous sha, as the DiffWith command will
-						sha: commit.unresolvedPreviousSha,
-						uri: commit.file.originalUri ?? commit.file.uri,
-					},
-					rhs: {
-						sha: commit.sha,
-						uri: commit.file.uri,
-					},
+					// Don't need to worry about verifying the previous sha, as the DiffWith command will
+					lhs: { sha: commit.unresolvedPreviousSha, uri: commit.file.originalUri ?? commit.file.uri },
+					rhs: { sha: commit.sha, uri: commit.file.uri },
 					line: line,
 				};
 			}
@@ -84,111 +74,107 @@ export class DiffWithCommand extends GlCommandBase {
 	async execute(args?: DiffWithCommandArgs): Promise<any> {
 		if (args?.lhs == null || args?.rhs == null) return;
 
-		args = {
-			...args,
-			lhs: { ...args.lhs },
-			rhs: { ...args.rhs },
-			showOptions: args.showOptions == null ? undefined : { ...args.showOptions },
-		};
-
-		if (args.repoPath == null) return;
+		const repo = args.repoPath ? this.container.git.getRepository(args.repoPath) : undefined;
+		if (repo == null) return;
 
 		try {
-			let lhsSha = args.lhs.sha;
-			let rhsSha = args.rhs.sha;
-
-			[args.lhs.sha, args.rhs.sha] = await Promise.all([
-				await this.container.git.refs(args.repoPath).resolveReference(args.lhs.sha, args.lhs.uri, {
-					// If the ref looks like a sha, don't wait too long, since it should work
-					timeout: isShaWithOptionalRevisionSuffix(args.lhs.sha) ? 100 : undefined,
-				}),
-				await this.container.git.refs(args.repoPath).resolveReference(args.rhs.sha, args.rhs.uri, {
-					// If the ref looks like a sha, don't wait too long, since it should work
-					timeout: isShaWithOptionalRevisionSuffix(args.rhs.sha) ? 100 : undefined,
-				}),
+			let {
+				lhs: { sha: lhsSha, uri: lhsUri, title: lhsTitle },
+				rhs: { sha: rhsSha, uri: rhsUri, title: rhsTitle },
+			} = args;
+			const showOptions = { viewColumn: ViewColumn.Active, ...args.showOptions };
+
+			let [lhsResolvedResult, rhsResolvedResult] = await Promise.allSettled([
+				repo.git.revision().resolveRevision(lhsSha, lhsUri),
+				repo.git.revision().resolveRevision(rhsSha, rhsUri),
 			]);
 
-			if (args.lhs.sha !== deletedOrMissing) {
-				lhsSha = args.lhs.sha;
-			}
+			let lhsResolved = getSettledValue(lhsResolvedResult)!;
+			let rhsResolved = getSettledValue(rhsResolvedResult)!;
 
-			if (args.rhs.sha && args.rhs.sha !== deletedOrMissing) {
-				// Ensure that the file still exists in this commit
-				const status = await this.container.git
-					.commits(args.repoPath)
-					.getCommitFileStatus(args.rhs.uri, args.rhs.sha);
-				if (status?.status === 'D') {
-					args.rhs.sha = deletedOrMissing;
-				} else {
-					rhsSha = args.rhs.sha;
-				}
+			// If both are missing, check for renames by swapping the paths
+			if (lhsResolved.sha === deletedOrMissing && rhsResolved.sha === deletedOrMissing) {
+				[lhsResolvedResult, rhsResolvedResult] = await Promise.allSettled([
+					repo?.git.revision().resolveRevision(lhsSha, rhsUri),
+					repo?.git.revision().resolveRevision(rhsSha, lhsUri),
+				]);
 
-				if (status?.status === 'A' && args.lhs.sha.endsWith('^')) {
-					args.lhs.sha = deletedOrMissing;
+				lhsResolved = getSettledValue(lhsResolvedResult)!;
+				rhsResolved = getSettledValue(rhsResolvedResult)!;
+
+				if (lhsResolved.sha !== deletedOrMissing || rhsResolved.sha !== deletedOrMissing) {
+					[lhsTitle, rhsTitle] = [rhsTitle, lhsTitle];
+					[lhsUri, rhsUri] = [rhsUri, lhsUri];
 				}
 			}
 
-			const [lhs, rhs] = await Promise.all([
-				this.container.git.getBestRevisionUri(args.repoPath, args.lhs.uri.fsPath, args.lhs.sha),
-				this.container.git.getBestRevisionUri(args.repoPath, args.rhs.uri.fsPath, args.rhs.sha),
+			if (rhsResolved.status === 'D') {
+				rhsResolved.sha = deletedOrMissing;
+			} else if (rhsResolved.status === 'R' || rhsResolved.status === 'C') {
+				rhsUri = this.container.git.getAbsoluteUri(rhsResolved.path!, args.repoPath);
+			} else if (rhsResolved.status === 'A' && isShaWithParentSuffix(lhsResolved.sha)) {
+				lhsResolved.sha = deletedOrMissing;
+			}
+
+			const [lhsResult, rhsResult] = await Promise.allSettled([
+				repo.git.getBestRevisionUri(lhsUri.fsPath, lhsResolved.sha),
+				repo.git.getBestRevisionUri(rhsUri.fsPath, rhsResolved.sha),
 			]);
 
-			let rhsSuffix = shortenRevision(rhsSha, { strings: { uncommitted: 'Working Tree' } });
+			const lhs = getSettledValue(lhsResult);
+			const rhs = getSettledValue(rhsResult);
+
+			let rhsSuffix = shortenRevision(rhsResolved.revision);
 			if (rhs == null) {
-				if (isUncommitted(args.rhs.sha)) {
-					rhsSuffix = 'deleted';
-				} else if (rhsSuffix.length === 0 && args.rhs.sha === deletedOrMissing) {
-					rhsSuffix = 'not in Working Tree';
+				if (isUncommitted(rhsResolved.sha)) {
+					rhsSuffix = 'Deleted';
+				} else if (!rhsSuffix && rhsResolved.sha === deletedOrMissing) {
+					rhsSuffix = 'Not in Working Tree';
 				} else {
-					rhsSuffix = `deleted${rhsSuffix.length === 0 ? '' : ` in ${rhsSuffix}`}`;
+					rhsSuffix = `${args.fromComparison ? 'Missing' : 'Deleted'}${!rhsSuffix ? '' : ` in ${rhsSuffix}`}`;
 				}
 			} else if (lhs == null) {
-				rhsSuffix = `added${rhsSuffix.length === 0 ? '' : ` in ${rhsSuffix}`}`;
+				if (!args.fromComparison) {
+					rhsSuffix = `Added${!rhsSuffix ? '' : ` in ${rhsSuffix}`}`;
+				}
 			}
 
-			let lhsSuffix = args.lhs.sha !== deletedOrMissing ? shortenRevision(lhsSha) : '';
-			if (lhs == null && args.rhs.sha.length === 0) {
+			let lhsSuffix = shortenRevision(lhsResolved.revision);
+			if (lhsResolved.sha === deletedOrMissing) {
+				lhsSuffix = args.fromComparison ? `Missing${!lhsSuffix ? '' : ` in ${lhsSuffix}`}` : '';
+			}
+			if (lhs == null && !rhsResolved.sha) {
 				if (rhs != null) {
-					lhsSuffix = lhsSuffix.length === 0 ? '' : `not in ${lhsSuffix}`;
+					lhsSuffix = !lhsSuffix ? '' : `Not in ${lhsSuffix}`;
 					rhsSuffix = '';
 				} else {
-					lhsSuffix = `deleted${lhsSuffix.length === 0 ? '' : ` in ${lhsSuffix}`}`;
+					lhsSuffix = `${args.fromComparison ? 'Missing' : 'Deleted'}${!lhsSuffix ? '' : ` in ${lhsSuffix}`}`;
 				}
 			}
 
-			if (args.lhs.title == null && (lhs != null || lhsSuffix.length !== 0)) {
-				args.lhs.title = `${basename(args.lhs.uri.fsPath)}${lhsSuffix ? ` (${lhsSuffix})` : ''}`;
-			}
-			if (args.rhs.title == null) {
-				args.rhs.title = `${basename(args.rhs.uri.fsPath)}${rhsSuffix ? ` (${rhsSuffix})` : ''}`;
+			if (lhsTitle == null && (lhs != null || lhsSuffix)) {
+				lhsTitle = `${basename(args.lhs.uri.fsPath)}${lhsSuffix ? ` (${lhsSuffix})` : ''}`;
 			}
+			rhsTitle ??= `${basename(args.rhs.uri.fsPath)}${rhsSuffix ? ` (${rhsSuffix})` : ''}`;
 
 			const title =
-				args.lhs.title != null && args.rhs.title != null
-					? `${args.lhs.title} ${GlyphChars.ArrowLeftRightLong} ${args.rhs.title}`
-					: args.lhs.title ?? args.rhs.title;
-
-			if (args.showOptions == null) {
-				args.showOptions = {};
-			}
-
-			if (args.showOptions.viewColumn == null) {
-				args.showOptions.viewColumn = ViewColumn.Active;
-			}
+				lhsTitle != null && rhsTitle != null
+					? `${lhsTitle} ${GlyphChars.ArrowLeftRightLong} ${rhsTitle}`
+					: lhsTitle ?? rhsTitle;
 
-			if (args.line != null && args.line !== 0) {
-				args.showOptions.selection = new Range(args.line, 0, args.line, 0);
+			if (args.line) {
+				showOptions.selection = new Range(args.line, 0, args.line, 0);
 			}
 
 			await openDiffEditor(
-				lhs ?? this.container.git.getRevisionUri(args.repoPath, deletedOrMissing, args.lhs.uri.fsPath),
-				rhs ?? this.container.git.getRevisionUri(args.repoPath, deletedOrMissing, args.rhs.uri.fsPath),
+				lhs ?? repo.git.getRevisionUri(deletedOrMissing, args.lhs.uri.fsPath),
+				rhs ?? repo.git.getRevisionUri(deletedOrMissing, args.rhs.uri.fsPath),
 				title,
 				args.showOptions,
 			);
 		} catch (ex) {
-			Logger.error(ex, 'DiffWithCommand', 'getVersionedFile');
-			void showGenericErrorMessage('Unable to open compare');
+			Logger.error(ex, 'DiffWithCommand');
+			void showGenericErrorMessage('Unable to open comparison');
 		}
 	}
 }

src/commands/git/show.ts

@@ -152,7 +152,6 @@ export class ShowGitCommand extends QuickCommand<State> {
 							repoPath: state.repo.path,
 							commits: new Map<string, GitCommit | GitStashCommit>(),
 							sha: undefined,
-							range: undefined,
 							count: 0,
 							limit: undefined,
 							hasMore: false,

src/commands/git/worktree.ts

@@ -1202,9 +1202,7 @@ export class WorktreeGitCommand extends QuickCommand<State> {
 			}
 
 			if (!isSha(state.changes.baseSha)) {
-				const sha = await state.repo.git
-					.refs()
-					.resolveReference(state.changes.baseSha, undefined, { force: true });
+				const sha = (await state.repo.git.revision().resolveRevision(state.changes.baseSha)).sha;
 				if (sha != null) {
 					state.changes.baseSha = sha;
 				}

src/commands/openOnRemote.ts

@@ -70,9 +70,11 @@ export class OpenOnRemoteCommand extends GlCommandBase {
 						const file = await commit.findFile(fileName);
 						if (file?.status === 'D') {
 							// Resolve to the previous commit to that file
-							resource.sha = await this.container.git
-								.refs(commit.repoPath)
-								.resolveReference(`${commit.sha}^`, fileName);
+							resource.sha = (
+								await this.container.git
+									.revision(commit.repoPath)
+									.resolveRevision(`${commit.sha}^`, fileName)
+							).sha;
 						} else {
 							resource.sha = commit.sha;
 						}

src/config.ts

@@ -190,6 +190,9 @@ export interface AdvancedConfig {
 		readonly gitPath: boolean;
 	};
 	readonly commitOrdering: 'date' | 'author-date' | 'topo' | null;
+	readonly commits: {
+		readonly delayLoadingFileDetails: boolean;
+	};
 	readonly externalDiffTool: string | null;
 	readonly externalDirectoryDiffTool: string | null;
 	readonly fileHistoryFollowsRenames: boolean;