errors,locking,ssh: use standard error joining

As of Go 1.24, if the Go version number in the "go.mod" file is set to
1.24 or higher, the "go vet" command now reports misuses of non-constant
strings as format strings.  In previous commits in this PR we have now
resolved all but one of the instances where we provided a non-constant
string as a format string.  The remaining instance is our use of the
Errorf() function of the "fmt" package from the Go standard library
at the end of the Combine() function in our "errors" package.

The Combine() function was added to our custom "errors" package in
commit 08e3e5b of PR git-lfs#1870, originally
for use in the "locking" package.  This function merges multiple
errors into a single error by concatenating their error messages
with a newline separator character between each original message.

In Go 1.20 the Join() function was added to the "errors" package
of the Go standard library, and it performs the same concatenation
of error messages as our Combine() function, including the use of a
newline character as a separator between the original messages, except
that it delays the concatenation until the Error() method is called.

To resolve the remaining case where we pass a non-constant string as
a format string, we remove the Combine() function from our "errors"
package and replace it with a Join() function that simply invokes
the Join() function of the standard library's "errors" package,
which we can expect to be defined as we currently require the use of
at least Go 1.21 (per the Go version specified in our "go.mod" file).

To make this change, we alias the standard library's "errors" package
as "goerrors", following the pattern established in our "lfshttp"
package where we use that alias as well.

We then revise the two callers of our Combine() function to make
use of the new Join() function instead.  One of these callers is the
startConnection() function in our "ssh" package, which simply joins
two errors, and the other caller is the FixLockableFileWriteFlags()
method of the Client structure in our "locking" package, which
collects zero or more errors while iterating over a list of files
and repeatedly calling another method.

Because the Join() functions accept variadic arguments rather than
an array of errors, we revise these callers to pass the errors
they intend to concatenate as direct arguments rather than in an
array.  For the FixLockableFileWriteFlags() method this means that
as it iterates over its list of files, if any errors occur we
immediately call the Join() function to add them to the error value
we return at the end of the function, whereas previously we appended
the errors to an array, and then called the Combine() function after
the loop exited to concatenate any errors in the array into the
function's final error return value.

Author: chrisd8088

errors/errors.go

@@ -50,7 +50,7 @@ package errors
 // docs for more info: https://godoc.org/github.com/pkg/errors
 
 import (
-	"bytes"
+	goerrors "errors"
 	"fmt"
 
 	"github.com/pkg/errors"
@@ -102,19 +102,8 @@ func StackTrace(err error) []string {
 	return nil
 }
 
-func Combine(errs []error) error {
-	if len(errs) == 0 {
-		return nil
-	}
-
-	var buf bytes.Buffer
-	for i, err := range errs {
-		if i > 0 {
-			buf.WriteString("\n")
-		}
-		buf.WriteString(err.Error())
-	}
-	return fmt.Errorf(buf.String())
+func Join(errs ...error) error {
+	return goerrors.Join(errs...)
 }
 
 func Cause(err error) error {

locking/lockable.go

@@ -142,15 +142,15 @@ func (c *Client) FixLockableFileWriteFlags(files []string) error {
 		return nil
 	}
 
-	var errs []error
+	var multiErr error
 	for _, f := range files {
 		err := c.fixSingleFileWriteFlags(f, c.getLockableFilter(), nil)
 		if err != nil {
-			errs = append(errs, err)
+			multiErr = errors.Join(multiErr, err)
 		}
 	}
 
-	return errors.Combine(errs)
+	return multiErr
 }
 
 // fixSingleFileWriteFlags fixes write flags on a single file

ssh/connection.go

@@ -79,7 +79,7 @@ func startConnection(id int, osEnv config.Environment, gitEnv config.Environment
 		r.Close()
 		w.Close()
 		cmd.Wait()
-		err = errors.Combine([]error{err, errors.New(tr.Tr.Get("Failed to connect to remote SSH server: %s", cmd.Stderr))})
+		err = errors.Join(err, errors.New(tr.Tr.Get("Failed to connect to remote SSH server: %s", cmd.Stderr)))
 		tracerx.Printf("pure SSH connection unsuccessful (#%d)", id)
 	} else {
 		tracerx.Printf("pure SSH connection successful (#%d)", id)