Add field name for git.Flag

Go vet, editors, and other tooling will emit warnings when a struct
doens't have the fields names, as it falls back on ordering. That could
introduce bugs when new fields are added with the same type at the
beginning of a struct.

To reduce the number of warnings in my editor, I ran a `sed` script to
update the code.

37 files changed, 84 insertions, 84 deletions

diff --git a/STYLE.md b/STYLE.md
index c4b31667b..f3b884899 100644
--- a/STYLE.md
+++ b/STYLE.md
@@ -239,15 +239,15 @@ important to mitigate these injection risks:
 
 - When toggling an option, prefer a longer flag over a short flag for
   readability.
-	- Desired: `git.Flag{"--long-flag"}` is easier to read and audit
-	- Undesired: `git.Flag{"-L"}`
+	- Desired: `git.Flag{Name: "--long-flag"}` is easier to read and audit
+	- Undesired: `git.Flag{Name: "-L"}`
 - When providing a variable to configure a flag, make sure to include the
   variable after an equal sign
-	- Desired: `[]git.Flag{"-a="+foo}` prevents flag injection
-	- Undesired: `[]git.Flag("-a"+foo)` allows flag injection
+	- Desired: `[]git.Flag{Name: "-a="+foo}` prevents flag injection
+	- Undesired: `[]git.Flag(Name: "-a"+foo)` allows flag injection
 - Always define a flag's name via a constant, never use a variable:
-	- Desired: `[]git.Flag{"-a"}`
-	- Undesired: `[]git.Flag{foo}` is ambiguous and difficult to audit
+	- Desired: `[]git.Flag{Name: "-a"}`
+	- Undesired: `[]git.Flag{Name: foo}` is ambiguous and difficult to audit
 
 ## Go Imports Style
 
diff --git a/internal/git/catfile/batch.go b/internal/git/catfile/batch.go
index 8f6e37bfd..759899091 100644
--- a/internal/git/catfile/batch.go
+++ b/internal/git/catfile/batch.go
@@ -46,7 +46,7 @@ func newBatchProcess(ctx context.Context, repo repository.GitRepo) (*batchProces
 
 	batchCmd, err := git.SafeBareCmd(ctx, git.CmdStream{In: stdinReader}, env,
 		[]git.Option{git.ValueFlag{Name: "--git-dir", Value: repoPath}},
-		git.SubCmd{Name: "cat-file", Flags: []git.Option{git.Flag{"--batch"}}})
+		git.SubCmd{Name: "cat-file", Flags: []git.Option{git.Flag{Name: "--batch"}}})
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/git/catfile/batchcheck.go b/internal/git/catfile/batchcheck.go
index efa2bbe9e..00714b7a8 100644
--- a/internal/git/catfile/batchcheck.go
+++ b/internal/git/catfile/batchcheck.go
@@ -32,7 +32,7 @@ func newBatchCheck(ctx context.Context, repo repository.GitRepo) (*batchCheck, e
 
 	batchCmd, err := git.SafeBareCmd(ctx, git.CmdStream{In: stdinReader}, env,
 		[]git.Option{git.ValueFlag{Name: "--git-dir", Value: repoPath}},
-		git.SubCmd{Name: "cat-file", Flags: []git.Option{git.Flag{"--batch-check"}}})
+		git.SubCmd{Name: "cat-file", Flags: []git.Option{git.Flag{Name: "--batch-check"}}})
 	if err != nil {
 		return nil, err
 	}
diff --git a/internal/git/log/last_commit.go b/internal/git/log/last_commit.go
index 7ad13aa02..6c29a64e6 100644
--- a/internal/git/log/last_commit.go
+++ b/internal/git/log/last_commit.go
@@ -15,7 +15,7 @@ import (
 func LastCommitForPath(ctx context.Context, batch *catfile.Batch, repo *gitalypb.Repository, revision string, path string, options *gitalypb.GlobalOptions) (*gitalypb.GitCommit, error) {
 	cmd, err := git.SafeCmd(ctx, repo, git.ConvertGlobalOptions(options), git.SubCmd{
 		Name:        "log",
-		Flags:       []git.Option{git.Flag{"--format=%H"}, git.Flag{"--max-count=1"}},
+		Flags:       []git.Option{git.Flag{Name: "--format=%H"}, git.Flag{Name: "--max-count=1"}},
 		Args:        []string{revision},
 		PostSepArgs: []string{path}})
 	if err != nil {
@@ -34,7 +34,7 @@ func LastCommitForPath(ctx context.Context, batch *catfile.Batch, repo *gitalypb
 func GitLogCommand(ctx context.Context, repo *gitalypb.Repository, revisions []string, paths []string, options *gitalypb.GlobalOptions, extraArgs ...git.Option) (*command.Command, error) {
 	return git.SafeCmd(ctx, repo, git.ConvertGlobalOptions(options), git.SubCmd{
 		Name:        "log",
-		Flags:       append([]git.Option{git.Flag{"--pretty=%H"}}, extraArgs...),
+		Flags:       append([]git.Option{git.Flag{Name: "--pretty=%H"}}, extraArgs...),
 		Args:        revisions,
 		PostSepArgs: paths,
 	})
diff --git a/internal/git/objectpool/fetch.go b/internal/git/objectpool/fetch.go
index 9ebc8c231..2bcd3a599 100644
--- a/internal/git/objectpool/fetch.go
+++ b/internal/git/objectpool/fetch.go
@@ -84,7 +84,7 @@ func (o *ObjectPool) FetchFromOrigin(ctx context.Context, origin *gitalypb.Repos
 	refSpec := fmt.Sprintf("+refs/*:%s/*", sourceRefNamespace)
 	fetchCmd, err := git.SafeCmd(ctx, o, nil, git.SubCmd{
 		Name:  "fetch",
-		Flags: []git.Option{git.Flag{"--quiet"}},
+		Flags: []git.Option{git.Flag{Name: "--quiet"}},
 		Args:  []string{sourceRemote, refSpec},
 	})
 	if err != nil {
@@ -105,7 +105,7 @@ func (o *ObjectPool) FetchFromOrigin(ctx context.Context, origin *gitalypb.Repos
 
 	packRefs, err := git.SafeCmd(ctx, o, nil, git.SubCmd{
 		Name:  "pack-refs",
-		Flags: []git.Option{git.Flag{"--all"}},
+		Flags: []git.Option{git.Flag{Name: "--all"}},
 	})
 	if err != nil {
 		return err
@@ -130,7 +130,7 @@ const danglingObjectNamespace = "refs/dangling"
 func rescueDanglingObjects(ctx context.Context, repo repository.GitRepo) error {
 	fsck, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "fsck",
-		Flags: []git.Option{git.Flag{"--connectivity-only"}, git.Flag{"--dangling"}},
+		Flags: []git.Option{git.Flag{Name: "--connectivity-only"}, git.Flag{Name: "--dangling"}},
 	})
 	if err != nil {
 		return err
@@ -179,7 +179,7 @@ func repackPool(ctx context.Context, pool repository.GitRepo) error {
 
 	repackCmd, err := git.SafeCmd(ctx, pool, repackArgs, git.SubCmd{
 		Name:  "repack",
-		Flags: []git.Option{git.Flag{"-aidb"}},
+		Flags: []git.Option{git.Flag{Name: "-aidb"}},
 	})
 	if err != nil {
 		return err
@@ -210,7 +210,7 @@ func (o *ObjectPool) logStats(ctx context.Context, when string) error {
 
 	forEachRef, err := git.SafeCmd(ctx, o, nil, git.SubCmd{
 		Name:  "for-each-ref",
-		Flags: []git.Option{git.Flag{"--format=%(objecttype)"}},
+		Flags: []git.Option{git.Flag{Name: "--format=%(objecttype)"}},
 		Args:  []string{danglingObjectNamespace},
 	})
 	if err != nil {
diff --git a/internal/git/safecmd_test.go b/internal/git/safecmd_test.go
index 07f742bcc..6e5b767fa 100644
--- a/internal/git/safecmd_test.go
+++ b/internal/git/safecmd_test.go
@@ -17,13 +17,13 @@ func TestFlagValidation(t *testing.T) {
 		valid  bool
 	}{
 		// valid Flag inputs
-		{option: git.Flag{"-k"}, valid: true},
-		{option: git.Flag{"-K"}, valid: true},
-		{option: git.Flag{"--asdf"}, valid: true},
-		{option: git.Flag{"--asdf-qwer"}, valid: true},
-		{option: git.Flag{"--asdf=qwerty"}, valid: true},
-		{option: git.Flag{"-D=A"}, valid: true},
-		{option: git.Flag{"-D="}, valid: true},
+		{option: git.Flag{Name: "-k"}, valid: true},
+		{option: git.Flag{Name: "-K"}, valid: true},
+		{option: git.Flag{Name: "--asdf"}, valid: true},
+		{option: git.Flag{Name: "--asdf-qwer"}, valid: true},
+		{option: git.Flag{Name: "--asdf=qwerty"}, valid: true},
+		{option: git.Flag{Name: "-D=A"}, valid: true},
+		{option: git.Flag{Name: "-D="}, valid: true},
 
 		// valid ValueFlag inputs
 		{option: git.ValueFlag{"-k", "adsf"}, valid: true},
@@ -40,11 +40,11 @@ func TestFlagValidation(t *testing.T) {
 		{option: git.ConfigPair{"http.https://user@example.com/repo.git.user", "kitty"}, valid: true},
 
 		// invalid Flag inputs
-		{option: git.Flag{"-*"}},          // invalid character
-		{option: git.Flag{"a"}},           // missing dash
-		{option: git.Flag{"[["}},          // suspicious characters
-		{option: git.Flag{"||"}},          // suspicious characters
-		{option: git.Flag{"asdf=qwerty"}}, // missing dash
+		{option: git.Flag{Name: "-*"}},          // invalid character
+		{option: git.Flag{Name: "a"}},           // missing dash
+		{option: git.Flag{Name: "[["}},          // suspicious characters
+		{option: git.Flag{Name: "||"}},          // suspicious characters
+		{option: git.Flag{Name: "asdf=qwerty"}}, // missing dash
 
 		// invalid ValueFlag inputs
 		{option: git.ValueFlag{"k", "asdf"}}, // missing dash
@@ -85,7 +85,7 @@ func TestSafeCmdInvalidArg(t *testing.T) {
 		{
 			subCmd: git.SubCmd{
 				Name:  "meow",
-				Flags: []git.Option{git.Flag{"woof"}},
+				Flags: []git.Option{git.Flag{Name: "woof"}},
 			},
 			errMsg: `flag "woof" failed regex validation: invalid argument`,
 		},
@@ -138,7 +138,7 @@ func TestSafeCmdValid(t *testing.T) {
 		},
 		{
 			globals: []git.Option{
-				git.Flag{"--aaaa-bbbb"},
+				git.Flag{Name: "--aaaa-bbbb"},
 			},
 			subCmd:     git.SubCmd{Name: "cccc"},
 			expectArgs: []string{"--aaaa-bbbb", "cccc", endOfOptions},
@@ -153,15 +153,15 @@ func TestSafeCmdValid(t *testing.T) {
 		},
 		{
 			globals: []git.Option{
-				git.Flag{"-a"},
+				git.Flag{Name: "-a"},
 				git.ValueFlag{"-b", "c"},
 			},
 			subCmd: git.SubCmd{
 				Name: "d",
 				Flags: []git.Option{
-					git.Flag{"-e"},
+					git.Flag{Name: "-e"},
 					git.ValueFlag{"-f", "g"},
-					git.Flag{"-h=i"},
+					git.Flag{Name: "-h=i"},
 				},
 				Args:        []string{"1", "2"},
 				PostSepArgs: []string{"3", "4", "5"},
@@ -174,14 +174,14 @@ func TestSafeCmdValid(t *testing.T) {
 				Flags: []git.Option{
 					git.SubSubCmd{"verb"},
 					git.OutputToStdout,
-					git.Flag{"--adjective"},
+					git.Flag{Name: "--adjective"},
 				},
 			},
 			expectArgs: []string{"noun", "verb", "-", "--adjective", endOfOptions},
 		},
 		{
 			globals: []git.Option{
-				git.Flag{"--contributing"},
+				git.Flag{Name: "--contributing"},
 				git.ValueFlag{"--author", "a-gopher"},
 			},
 			subCmd: git.SubCmd{
diff --git a/internal/git/updateref/updateref.go b/internal/git/updateref/updateref.go
index 573aa8bd1..10d9901ca 100644
--- a/internal/git/updateref/updateref.go
+++ b/internal/git/updateref/updateref.go
@@ -26,7 +26,7 @@ type Updater struct {
 func New(ctx context.Context, repo repository.GitRepo) (*Updater, error) {
 	cmd, err := git.SafeStdinCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "update-ref",
-		Flags: []git.Option{git.Flag{"-z"}, git.Flag{"--stdin"}},
+		Flags: []git.Option{git.Flag{Name: "-z"}, git.Flag{Name: "--stdin"}},
 	})
 	if err != nil {
 		return nil, err
diff --git a/internal/service/commit/between.go b/internal/service/commit/between.go
index 271005860..2a424ab48 100644
--- a/internal/service/commit/between.go
+++ b/internal/service/commit/between.go
@@ -31,7 +31,7 @@ func (s *server) CommitsBetween(in *gitalypb.CommitsBetweenRequest, stream gital
 	sender := &commitsBetweenSender{stream: stream}
 	revisionRange := fmt.Sprintf("%s..%s", in.GetFrom(), in.GetTo())
 
-	if err := sendCommits(stream.Context(), sender, in.GetRepository(), []string{revisionRange}, nil, nil, git.Flag{"--reverse"}); err != nil {
+	if err := sendCommits(stream.Context(), sender, in.GetRepository(), []string{revisionRange}, nil, nil, git.Flag{Name: "--reverse"}); err != nil {
 		return helper.ErrInternal(err)
 	}
 
diff --git a/internal/service/commit/commits_by_message.go b/internal/service/commit/commits_by_message.go
index 99ab171b5..9a2388202 100644
--- a/internal/service/commit/commits_by_message.go
+++ b/internal/service/commit/commits_by_message.go
@@ -40,14 +40,14 @@ func commitsByMessage(in *gitalypb.CommitsByMessageRequest, stream gitalypb.Comm
 	sender := &commitsByMessageSender{stream: stream}
 
 	gitLogExtraOptions := []git.Option{
-		git.Flag{"--grep=" + in.GetQuery()},
-		git.Flag{"--regexp-ignore-case"},
+		git.Flag{Name: "--grep=" + in.GetQuery()},
+		git.Flag{Name: "--regexp-ignore-case"},
 	}
 	if offset := in.GetOffset(); offset > 0 {
-		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{fmt.Sprintf("--skip=%d", offset)})
+		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{Name: fmt.Sprintf("--skip=%d", offset)})
 	}
 	if limit := in.GetLimit(); limit > 0 {
-		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{fmt.Sprintf("--max-count=%d", limit)})
+		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{Name: fmt.Sprintf("--max-count=%d", limit)})
 	}
 
 	revision := in.GetRevision()
diff --git a/internal/service/commit/find_all_commits.go b/internal/service/commit/find_all_commits.go
index c93d2f0b0..9859ca99f 100644
--- a/internal/service/commit/find_all_commits.go
+++ b/internal/service/commit/find_all_commits.go
@@ -66,18 +66,18 @@ func findAllCommits(in *gitalypb.FindAllCommitsRequest, stream gitalypb.CommitSe
 
 	var gitLogExtraOptions []git.Option
 	if maxCount := in.GetMaxCount(); maxCount > 0 {
-		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{fmt.Sprintf("--max-count=%d", maxCount)})
+		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{Name: fmt.Sprintf("--max-count=%d", maxCount)})
 	}
 	if skip := in.GetSkip(); skip > 0 {
-		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{fmt.Sprintf("--skip=%d", skip)})
+		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{Name: fmt.Sprintf("--skip=%d", skip)})
 	}
 	switch in.GetOrder() {
 	case gitalypb.FindAllCommitsRequest_NONE:
 		// Do nothing
 	case gitalypb.FindAllCommitsRequest_DATE:
-		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{"--date-order"})
+		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{Name: "--date-order"})
 	case gitalypb.FindAllCommitsRequest_TOPO:
-		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{"--topo-order"})
+		gitLogExtraOptions = append(gitLogExtraOptions, git.Flag{Name: "--topo-order"})
 	}
 
 	return sendCommits(stream.Context(), sender, in.GetRepository(), revisions, nil, nil, gitLogExtraOptions...)
diff --git a/internal/service/commit/languages.go b/internal/service/commit/languages.go
index a6edea4fd..8f5cae955 100644
--- a/internal/service/commit/languages.go
+++ b/internal/service/commit/languages.go
@@ -152,7 +152,7 @@ func checkRevision(ctx context.Context, repoPath string, env []string, revision
 func disambiguateRevision(ctx context.Context, repo *gitalypb.Repository, revision string) (string, error) {
 	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "for-each-ref",
-		Flags: []git.Option{git.Flag{"--format=%(refname)"}},
+		Flags: []git.Option{git.Flag{Name: "--format=%(refname)"}},
 		Args:  []string{"**/" + revision},
 	})
 
diff --git a/internal/service/commit/raw_blame.go b/internal/service/commit/raw_blame.go
index 6b7aacac5..9c8100c81 100644
--- a/internal/service/commit/raw_blame.go
+++ b/internal/service/commit/raw_blame.go
@@ -23,7 +23,7 @@ func (s *server) RawBlame(in *gitalypb.RawBlameRequest, stream gitalypb.CommitSe
 
 	cmd, err := git.SafeCmd(ctx, in.Repository, nil, git.SubCmd{
 		Name:        "blame",
-		Flags:       []git.Option{git.Flag{"-p"}},
+		Flags:       []git.Option{git.Flag{Name: "-p"}},
 		Args:        []string{revision},
 		PostSepArgs: []string{path},
 	})
diff --git a/internal/service/commit/stats.go b/internal/service/commit/stats.go
index 8f2fc29f7..1eb7efd0a 100644
--- a/internal/service/commit/stats.go
+++ b/internal/service/commit/stats.go
@@ -45,7 +45,7 @@ func commitStats(ctx context.Context, in *gitalypb.CommitStatsRequest) (*gitalyp
 
 	cmd, err := git.SafeCmd(ctx, in.Repository, nil, git.SubCmd{
 		Name:  "diff",
-		Flags: []git.Option{git.Flag{"--numstat"}},
+		Flags: []git.Option{git.Flag{Name: "--numstat"}},
 		Args:  args,
 	})
 	if err != nil {
diff --git a/internal/service/diff/numstat.go b/internal/service/diff/numstat.go
index d843090b3..985e3d557 100644
--- a/internal/service/diff/numstat.go
+++ b/internal/service/diff/numstat.go
@@ -23,7 +23,7 @@ func (s *server) DiffStats(in *gitalypb.DiffStatsRequest, stream gitalypb.DiffSe
 	var batch []*gitalypb.DiffStats
 	cmd, err := git.SafeCmd(stream.Context(), in.Repository, nil, git.SubCmd{
 		Name:  "diff",
-		Flags: []git.Option{git.Flag{"--numstat"}, git.Flag{"-z"}},
+		Flags: []git.Option{git.Flag{Name: "--numstat"}, git.Flag{Name: "-z"}},
 		Args:  []string{in.LeftCommitId, in.RightCommitId},
 	})
 
diff --git a/internal/service/diff/raw.go b/internal/service/diff/raw.go
index fb9540813..5e47936f0 100644
--- a/internal/service/diff/raw.go
+++ b/internal/service/diff/raw.go
@@ -18,7 +18,7 @@ func (s *server) RawDiff(in *gitalypb.RawDiffRequest, stream gitalypb.DiffServic
 
 	subCmd := git.SubCmd{
 		Name:  "diff",
-		Flags: []git.Option{git.Flag{"--full-index"}},
+		Flags: []git.Option{git.Flag{Name: "--full-index"}},
 		Args:  []string{in.LeftCommitId, in.RightCommitId},
 	}
 
@@ -36,7 +36,7 @@ func (s *server) RawPatch(in *gitalypb.RawPatchRequest, stream gitalypb.DiffServ
 
 	subCmd := git.SubCmd{
 		Name:  "format-patch",
-		Flags: []git.Option{git.Flag{"--stdout"}, git.ValueFlag{"--signature", "GitLab"}},
+		Flags: []git.Option{git.Flag{Name: "--stdout"}, git.ValueFlag{"--signature", "GitLab"}},
 		Args:  []string{in.LeftCommitId + ".." + in.RightCommitId},
 	}
 
diff --git a/internal/service/objectpool/alternates.go b/internal/service/objectpool/alternates.go
index c43e074ea..04f25ca86 100644
--- a/internal/service/objectpool/alternates.go
+++ b/internal/service/objectpool/alternates.go
@@ -202,7 +202,7 @@ func removeAlternatesIfOk(ctx context.Context, repo *gitalypb.Repository, altFil
 
 	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "fsck",
-		Flags: []git.Option{git.Flag{"--connectivity-only"}},
+		Flags: []git.Option{git.Flag{Name: "--connectivity-only"}},
 	})
 	if err != nil {
 		return err
diff --git a/internal/service/objectpool/reduplicate.go b/internal/service/objectpool/reduplicate.go
index d1a2f2267..9778535cd 100644
--- a/internal/service/objectpool/reduplicate.go
+++ b/internal/service/objectpool/reduplicate.go
@@ -16,7 +16,7 @@ func (s *server) ReduplicateRepository(ctx context.Context, req *gitalypb.Redupl
 
 	cmd, err := git.SafeCmd(ctx, req.GetRepository(), nil, git.SubCmd{
 		Name:  "repack",
-		Flags: []git.Option{git.Flag{"--quiet"}, git.Flag{"-a"}},
+		Flags: []git.Option{git.Flag{Name: "--quiet"}, git.Flag{Name: "-a"}},
 	})
 	if err != nil {
 		return nil, err
diff --git a/internal/service/ref/branches.go b/internal/service/ref/branches.go
index 30a39cd55..968e9b034 100644
--- a/internal/service/ref/branches.go
+++ b/internal/service/ref/branches.go
@@ -28,7 +28,7 @@ func (s *server) FindBranch(ctx context.Context, req *gitalypb.FindBranchRequest
 
 	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "for-each-ref",
-		Flags: []git.Option{git.Flag{"--format=%(objectname)"}},
+		Flags: []git.Option{git.Flag{Name: "--format=%(objectname)"}},
 		Args:  []string{"refs/heads/" + refName},
 	})
 	if err != nil {
diff --git a/internal/service/ref/delete_refs.go b/internal/service/ref/delete_refs.go
index a5fbde68a..4b0baa11e 100644
--- a/internal/service/ref/delete_refs.go
+++ b/internal/service/ref/delete_refs.go
@@ -53,7 +53,7 @@ func refsToRemove(ctx context.Context, req *gitalypb.DeleteRefsRequest) ([]strin
 
 	cmd, err := git.SafeCmd(ctx, req.GetRepository(), nil, git.SubCmd{
 		Name:  "for-each-ref",
-		Flags: []git.Option{git.Flag{"--format=%(refname)"}},
+		Flags: []git.Option{git.Flag{Name: "--format=%(refname)"}},
 	})
 	if err != nil {
 		return nil, fmt.Errorf("error setting up for-each-ref command: %v", err)
diff --git a/internal/service/ref/pack_refs.go b/internal/service/ref/pack_refs.go
index 9540e4a4d..51e457750 100644
--- a/internal/service/ref/pack_refs.go
+++ b/internal/service/ref/pack_refs.go
@@ -33,7 +33,7 @@ func validatePackRefsRequest(in *gitalypb.PackRefsRequest) error {
 func packRefs(ctx context.Context, repository repository.GitRepo, all bool) error {
 	cmd, err := git.SafeCmd(ctx, repository, nil, git.SubCmd{
 		Name:  "pack-refs",
-		Flags: []git.Option{git.Flag{"--all"}},
+		Flags: []git.Option{git.Flag{Name: "--all"}},
 	})
 	if err != nil {
 		return fmt.Errorf("initializing pack-refs command: %v", err)
diff --git a/internal/service/ref/refexists.go b/internal/service/ref/refexists.go
index 975b3ee06..b463d1b2c 100644
--- a/internal/service/ref/refexists.go
+++ b/internal/service/ref/refexists.go
@@ -30,7 +30,7 @@ func (server) RefExists(ctx context.Context, in *gitalypb.RefExistsRequest) (*gi
 func refExists(ctx context.Context, repo *gitalypb.Repository, ref string) (bool, error) {
 	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "show-ref",
-		Flags: []git.Option{git.Flag{"--verify"}, git.Flag{"--quiet"}},
+		Flags: []git.Option{git.Flag{Name: "--verify"}, git.Flag{Name: "--quiet"}},
 		Args:  []string{ref},
 	})
 	if err != nil {
diff --git a/internal/service/ref/refname.go b/internal/service/ref/refname.go
index 100743527..fdd8a4c2c 100644
--- a/internal/service/ref/refname.go
+++ b/internal/service/ref/refname.go
@@ -31,8 +31,8 @@ func (s *server) FindRefName(ctx context.Context, in *gitalypb.FindRefNameReques
 // We assume `repo` and `commitID` and `prefix` are non-empty
 func findRefName(ctx context.Context, repo *gitalypb.Repository, commitID, prefix string) (string, error) {
 	flags := []git.Option{
-		git.Flag{"--format=%(refname)"},
-		git.Flag{"--count=1"},
+		git.Flag{Name: "--format=%(refname)"},
+		git.Flag{Name: "--count=1"},
 	}
 
 	subCmd := ForEachRefCmd{PostArgFlags: []git.Option{
diff --git a/internal/service/ref/refname_test.go b/internal/service/ref/refname_test.go
index d69df4b9d..46699a56c 100644
--- a/internal/service/ref/refname_test.go
+++ b/internal/service/ref/refname_test.go
@@ -188,7 +188,7 @@ func TestFindRefCmd(t *testing.T) {
 			cmd: ForEachRefCmd{
 				SubCmd: git.SubCmd{
 					Name:  "for-each-ref",
-					Flags: []git.Option{git.Flag{"--tcl"}},
+					Flags: []git.Option{git.Flag{Name: "--tcl"}},
 					Args:  []string{"master"},
 				},
 			},
@@ -200,7 +200,7 @@ func TestFindRefCmd(t *testing.T) {
 			cmd: ForEachRefCmd{
 				SubCmd: git.SubCmd{
 					Name:  "for-each-ref",
-					Flags: []git.Option{git.Flag{"--tcl"}},
+					Flags: []git.Option{git.Flag{Name: "--tcl"}},
 					Args:  []string{"master"},
 				},
 				PostArgFlags: []git.Option{git.ValueFlag{Name: "--contains", Value: "blahblah"}},
diff --git a/internal/service/ref/refnames.go b/internal/service/ref/refnames.go
index 8a3ece87b..e4f12fb5d 100644
--- a/internal/service/ref/refnames.go
+++ b/internal/service/ref/refnames.go
@@ -55,7 +55,7 @@ func (ts *findAllTagNamesSender) Send() error {
 
 func listRefNames(ctx context.Context, chunker *chunk.Chunker, prefix string, repo *gitalypb.Repository, extraArgs []string) error {
 	flags := []git.Option{
-		git.Flag{"--format=%(refname)"},
+		git.Flag{Name: "--format=%(refname)"},
 	}
 
 	for _, arg := range extraArgs {
diff --git a/internal/service/ref/refs.go b/internal/service/ref/refs.go
index ce2d79abb..7e127c612 100644
--- a/internal/service/ref/refs.go
+++ b/internal/service/ref/refs.go
@@ -42,7 +42,7 @@ func findRefs(ctx context.Context, writer lines.Sender, repo *gitalypb.Repositor
 	var options []git.Option
 
 	if len(opts.cmdArgs) == 0 {
-		options = append(options, git.Flag{"--format=%(refname)"}) // Default format
+		options = append(options, git.Flag{Name: "--format=%(refname)"}) // Default format
 	} else {
 		options = append(options, opts.cmdArgs...)
 	}
@@ -158,7 +158,7 @@ func _findBranchNames(ctx context.Context, repo *gitalypb.Repository) ([][]byte,
 
 	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "for-each-ref",
-		Flags: []git.Option{git.Flag{"--format=%(refname)"}},
+		Flags: []git.Option{git.Flag{Name: "--format=%(refname)"}},
 		Args:  []string{"refs/heads"}},
 	)
 	if err != nil {
@@ -185,7 +185,7 @@ func _headReference(ctx context.Context, repo *gitalypb.Repository) ([]byte, err
 
 	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "rev-parse",
-		Flags: []git.Option{git.Flag{"--symbolic-full-name"}},
+		Flags: []git.Option{git.Flag{Name: "--symbolic-full-name"}},
 		Args:  []string{"HEAD"},
 	})
 	if err != nil {
@@ -308,8 +308,8 @@ func findLocalBranches(in *gitalypb.FindLocalBranchesRequest, stream gitalypb.Re
 	opts := paginationParamsToOpts(in.GetPaginationParams())
 	opts.cmdArgs = []git.Option{
 		// %00 inserts the null character into the output (see for-each-ref docs)
-		git.Flag{"--format=" + strings.Join(localBranchFormatFields, "%00")},
-		git.Flag{"--sort=" + parseSortKey(in.GetSortBy())},
+		git.Flag{Name: "--format=" + strings.Join(localBranchFormatFields, "%00")},
+		git.Flag{Name: "--sort=" + parseSortKey(in.GetSortBy())},
 	}
 
 	return findRefs(ctx, writer, in.Repository, []string{"refs/heads"}, opts)
@@ -326,7 +326,7 @@ func (s *server) FindAllBranches(in *gitalypb.FindAllBranchesRequest, stream git
 func findAllBranches(in *gitalypb.FindAllBranchesRequest, stream gitalypb.RefService_FindAllBranchesServer) error {
 	args := []git.Option{
 		// %00 inserts the null character into the output (see for-each-ref docs)
-		git.Flag{"--format=" + strings.Join(localBranchFormatFields, "%00")},
+		git.Flag{Name: "--format=" + strings.Join(localBranchFormatFields, "%00")},
 	}
 
 	patterns := []string{"refs/heads", "refs/remotes"}
@@ -415,7 +415,7 @@ func findTag(ctx context.Context, repository *gitalypb.Repository, tagName []byt
 	tagCmd, err := git.SafeCmd(ctx, repository, nil, git.SubCmd{
 		Name: "tag",
 		Flags: []git.Option{
-			git.Flag{"-l"}, git.ValueFlag{"--format", tagFormat},
+			git.Flag{Name: "-l"}, git.ValueFlag{"--format", tagFormat},
 		},
 		Args: []string{string(tagName)},
 	})
diff --git a/internal/service/ref/remote_branches.go b/internal/service/ref/remote_branches.go
index f82e9b3f8..f72b4d296 100644
--- a/internal/service/ref/remote_branches.go
+++ b/internal/service/ref/remote_branches.go
@@ -24,7 +24,7 @@ func (s *server) FindAllRemoteBranches(req *gitalypb.FindAllRemoteBranchesReques
 
 func findAllRemoteBranches(req *gitalypb.FindAllRemoteBranchesRequest, stream gitalypb.RefService_FindAllRemoteBranchesServer) error {
 	args := []git.Option{
-		git.Flag{"--format=" + strings.Join(localBranchFormatFields, "%00")},
+		git.Flag{Name: "--format=" + strings.Join(localBranchFormatFields, "%00")},
 	}
 
 	patterns := []string{"refs/remotes/" + req.GetRemoteName()}
diff --git a/internal/service/remote/fetch_internal_remote.go b/internal/service/remote/fetch_internal_remote.go
index 08863b24e..e57ff6d66 100644
--- a/internal/service/remote/fetch_internal_remote.go
+++ b/internal/service/remote/fetch_internal_remote.go
@@ -40,7 +40,7 @@ func (s *server) FetchInternalRemote(ctx context.Context, req *gitalypb.FetchInt
 		[]git.Option{git.ValueFlag{"--git-dir", repoPath}},
 		git.SubCmd{
 			Name:  "fetch",
-			Flags: []git.Option{git.Flag{"--prune"}},
+			Flags: []git.Option{git.Flag{Name: "--prune"}},
 			Args:  []string{gitalyInternalURL, mirrorRefSpec},
 		},
 	)
diff --git a/internal/service/repository/calculate_checksum.go b/internal/service/repository/calculate_checksum.go
index 1bd0622db..330aa1a21 100644
--- a/internal/service/repository/calculate_checksum.go
+++ b/internal/service/repository/calculate_checksum.go
@@ -29,7 +29,7 @@ func (s *server) CalculateChecksum(ctx context.Context, in *gitalypb.CalculateCh
 		return nil, err
 	}
 
-	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{Name: "show-ref", Flags: []git.Option{git.Flag{"--head"}}})
+	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{Name: "show-ref", Flags: []git.Option{git.Flag{Name: "--head"}}})
 	if err != nil {
 		if _, ok := status.FromError(err); ok {
 			return nil, err
@@ -85,7 +85,7 @@ func isValidRepo(ctx context.Context, repo *gitalypb.Repository) bool {
 	stdout := &bytes.Buffer{}
 	opts := []git.Option{git.ValueFlag{"-C", repoPath}}
 	cmd, err := git.SafeBareCmd(ctx, git.CmdStream{Out: stdout}, env, opts,
-		git.SubCmd{Name: "rev-parse", Flags: []git.Option{git.Flag{"--is-inside-git-dir"}}})
+		git.SubCmd{Name: "rev-parse", Flags: []git.Option{git.Flag{Name: "--is-inside-git-dir"}}})
 	if err != nil {
 		return false
 	}
diff --git a/internal/service/repository/clone_from_pool_internal.go b/internal/service/repository/clone_from_pool_internal.go
index 169357541..6a4ce902b 100644
--- a/internal/service/repository/clone_from_pool_internal.go
+++ b/internal/service/repository/clone_from_pool_internal.go
@@ -121,7 +121,7 @@ func (s *server) cloneFromPool(ctx context.Context, objectPoolRepo *gitalypb.Obj
 
 	cmd, err := git.SafeBareCmd(ctx, git.CmdStream{}, nil, nil, git.SubCmd{
 		Name:        "clone",
-		Flags:       []git.Option{git.Flag{"--bare"}, git.Flag{"--shared"}},
+		Flags:       []git.Option{git.Flag{Name: "--bare"}, git.Flag{Name: "--shared"}},
 		PostSepArgs: []string{objectPoolPath, repositoryPath},
 	})
 	if err != nil {
diff --git a/internal/service/repository/create_bundle.go b/internal/service/repository/create_bundle.go
index 3f85ce522..4f2d631c5 100644
--- a/internal/service/repository/create_bundle.go
+++ b/internal/service/repository/create_bundle.go
@@ -25,7 +25,7 @@ func (s *server) CreateBundle(req *gitalypb.CreateBundleRequest, stream gitalypb
 
 	cmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "bundle",
-		Flags: []git.Option{git.SubSubCmd{"create"}, git.OutputToStdout, git.Flag{"--all"}},
+		Flags: []git.Option{git.SubSubCmd{"create"}, git.OutputToStdout, git.Flag{Name: "--all"}},
 	})
 	if err != nil {
 		return status.Errorf(codes.Internal, "CreateBundle: cmd start failed: %v", err)
diff --git a/internal/service/repository/fetch.go b/internal/service/repository/fetch.go
index 523a92a71..a2d2c13a6 100644
--- a/internal/service/repository/fetch.go
+++ b/internal/service/repository/fetch.go
@@ -49,7 +49,7 @@ func (s *server) FetchSourceBranch(ctx context.Context, req *gitalypb.FetchSourc
 		[]git.Option{git.ValueFlag{"--git-dir", repoPath}},
 		git.SubCmd{
 			Name:  "fetch",
-			Flags: []git.Option{git.Flag{"--prune"}},
+			Flags: []git.Option{git.Flag{Name: "--prune"}},
 			Args:  []string{remote, refspec},
 		},
 	)
diff --git a/internal/service/repository/fork.go b/internal/service/repository/fork.go
index c9a39f4c5..2ec3abd98 100644
--- a/internal/service/repository/fork.go
+++ b/internal/service/repository/fork.go
@@ -45,7 +45,7 @@ func (s *server) CreateFork(ctx context.Context, req *gitalypb.CreateForkRequest
 
 	cmd, err := git.SafeBareCmd(ctx, git.CmdStream{}, env, nil, git.SubCmd{
 		Name:  "clone",
-		Flags: []git.Option{git.Flag{"--bare"}, git.Flag{"--no-local"}},
+		Flags: []git.Option{git.Flag{Name: "--bare"}, git.Flag{Name: "--no-local"}},
 		PostSepArgs: []string{
 			fmt.Sprintf("%s:%s", gitalyInternalURL, sourceRepository.RelativePath),
 			targetRepositoryFullPath,
diff --git a/internal/service/repository/raw_changes.go b/internal/service/repository/raw_changes.go
index 5ff3eec93..dab1d1fb1 100644
--- a/internal/service/repository/raw_changes.go
+++ b/internal/service/repository/raw_changes.go
@@ -63,7 +63,7 @@ func getRawChanges(stream gitalypb.RepositoryService_GetRawChangesServer, repo *
 
 	diffCmd, err := git.SafeCmd(ctx, repo, nil, git.SubCmd{
 		Name:  "diff",
-		Flags: []git.Option{git.Flag{"--raw"}, git.Flag{"-z"}},
+		Flags: []git.Option{git.Flag{Name: "--raw"}, git.Flag{Name: "-z"}},
 		Args:  []string{from, to},
 	})
 	if err != nil {
diff --git a/internal/service/repository/repack.go b/internal/service/repository/repack.go
index bb30a92a1..c4aa38b3a 100644
--- a/internal/service/repository/repack.go
+++ b/internal/service/repository/repack.go
@@ -29,9 +29,9 @@ func init() {
 
 func (*server) RepackFull(ctx context.Context, in *gitalypb.RepackFullRequest) (*gitalypb.RepackFullResponse, error) {
 	options := []git.Option{
-		git.Flag{"-A"},
-		git.Flag{"--pack-kept-objects"},
-		git.Flag{"-l"},
+		git.Flag{Name: "-A"},
+		git.Flag{Name: "--pack-kept-objects"},
+		git.Flag{Name: "-l"},
 	}
 	if err := repackCommand(ctx, in.GetRepository(), in.GetCreateBitmap(), options...); err != nil {
 		return nil, err
@@ -51,7 +51,7 @@ func repackCommand(ctx context.Context, repo repository.GitRepo, bitmap bool, ar
 		repackConfig(ctx, bitmap), // global configs
 		git.SubCmd{
 			Name:  "repack",
-			Flags: append([]git.Option{git.Flag{"-d"}}, args...),
+			Flags: append([]git.Option{git.Flag{Name: "-d"}}, args...),
 		},
 	)
 	if err != nil {
diff --git a/internal/service/smarthttp/inforefs.go b/internal/service/smarthttp/inforefs.go
index 55cbd8f1c..6e12f4aaa 100644
--- a/internal/service/smarthttp/inforefs.go
+++ b/internal/service/smarthttp/inforefs.go
@@ -65,7 +65,7 @@ func handleInfoRefs(ctx context.Context, service string, req *gitalypb.InfoRefsR
 
 	cmd, err := git.SafeBareCmd(ctx, git.CmdStream{}, env, globalOpts, git.SubCmd{
 		Name:  service,
-		Flags: []git.Option{git.Flag{"--stateless-rpc"}, git.Flag{"--advertise-refs"}},
+		Flags: []git.Option{git.Flag{Name: "--stateless-rpc"}, git.Flag{Name: "--advertise-refs"}},
 		Args:  []string{repoPath},
 	})
 
diff --git a/internal/service/smarthttp/receive_pack.go b/internal/service/smarthttp/receive_pack.go
index 1e895e9d4..2a5f38918 100644
--- a/internal/service/smarthttp/receive_pack.go
+++ b/internal/service/smarthttp/receive_pack.go
@@ -59,7 +59,7 @@ func (s *server) PostReceivePack(stream gitalypb.SmartHTTPService_PostReceivePac
 
 	cmd, err := git.SafeBareCmd(ctx, git.CmdStream{In: stdin, Out: stdout}, env, globalOpts, git.SubCmd{
 		Name:  "receive-pack",
-		Flags: []git.Option{git.Flag{"--stateless-rpc"}},
+		Flags: []git.Option{git.Flag{Name: "--stateless-rpc"}},
 		Args:  []string{repoPath},
 	})
 
diff --git a/internal/service/smarthttp/upload_pack.go b/internal/service/smarthttp/upload_pack.go
index eb3bdac87..a0107517b 100644
--- a/internal/service/smarthttp/upload_pack.go
+++ b/internal/service/smarthttp/upload_pack.go
@@ -82,7 +82,7 @@ func (s *server) PostUploadPack(stream gitalypb.SmartHTTPService_PostUploadPackS
 
 	cmd, err := git.SafeBareCmd(ctx, git.CmdStream{In: stdin, Out: stdout}, env, globalOpts, git.SubCmd{
 		Name:  "upload-pack",
-		Flags: []git.Option{git.Flag{"--stateless-rpc"}},
+		Flags: []git.Option{git.Flag{Name: "--stateless-rpc"}},
 		Args:  []string{repoPath},
 	})