all: gofmt -w -r 'interface{} -> any' (ent#2874)

Author: a8m

cmd/internal/base/packages_test.go

@@ -17,7 +17,7 @@ func testPkgPath(t *testing.T, x packagestest.Exporter) {
 	e := packagestest.Export(t, x, []packagestest.Module{
 		{
 			Name: "golang.org/x",
-			Files: map[string]interface{}{
+			Files: map[string]any{
 				"x.go":   "package x",
 				"y/y.go": "package y",
 			},

dialect/dialect.go

@@ -26,10 +26,10 @@ const (
 type ExecQuerier interface {
 	// Exec executes a query that does not return records. For example, in SQL, INSERT or UPDATE.
 	// It scans the result into the pointer v. For SQL drivers, it is dialect/sql.Result.
-	Exec(ctx context.Context, query string, args, v interface{}) error
+	Exec(ctx context.Context, query string, args, v any) error
 	// Query executes a query that returns rows, typically a SELECT in SQL.
 	// It scans the result into the pointer v. For SQL drivers, it is *dialect/sql.Rows.
-	Query(ctx context.Context, query string, args, v interface{}) error
+	Query(ctx context.Context, query string, args, v any) error
 }
 
 // Driver is the interface that wraps all necessary operations for ent clients.
@@ -65,38 +65,38 @@ func NopTx(d Driver) Tx {
 
 // DebugDriver is a driver that logs all driver operations.
 type DebugDriver struct {
-	Driver                                       // underlying driver.
-	log    func(context.Context, ...interface{}) // log function. defaults to log.Println.
+	Driver                               // underlying driver.
+	log    func(context.Context, ...any) // log function. defaults to log.Println.
 }
 
 // Debug gets a driver and an optional logging function, and returns
 // a new debugged-driver that prints all outgoing operations.
-func Debug(d Driver, logger ...func(...interface{})) Driver {
+func Debug(d Driver, logger ...func(...any)) Driver {
 	logf := log.Println
 	if len(logger) == 1 {
 		logf = logger[0]
 	}
-	drv := &DebugDriver{d, func(_ context.Context, v ...interface{}) { logf(v...) }}
+	drv := &DebugDriver{d, func(_ context.Context, v ...any) { logf(v...) }}
 	return drv
 }
 
 // DebugWithContext gets a driver and a logging function, and returns
 // a new debugged-driver that prints all outgoing operations with context.
-func DebugWithContext(d Driver, logger func(context.Context, ...interface{})) Driver {
+func DebugWithContext(d Driver, logger func(context.Context, ...any)) Driver {
 	drv := &DebugDriver{d, logger}
 	return drv
 }
 
 // Exec logs its params and calls the underlying driver Exec method.
-func (d *DebugDriver) Exec(ctx context.Context, query string, args, v interface{}) error {
+func (d *DebugDriver) Exec(ctx context.Context, query string, args, v any) error {
 	d.log(ctx, fmt.Sprintf("driver.Exec: query=%v args=%v", query, args))
 	return d.Driver.Exec(ctx, query, args, v)
 }
 
 // ExecContext logs its params and calls the underlying driver ExecContext method if it is supported.
-func (d *DebugDriver) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
+func (d *DebugDriver) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) {
 	drv, ok := d.Driver.(interface {
-		ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
+		ExecContext(context.Context, string, ...any) (sql.Result, error)
 	})
 	if !ok {
 		return nil, fmt.Errorf("Driver.ExecContext is not supported")
@@ -106,15 +106,15 @@ func (d *DebugDriver) ExecContext(ctx context.Context, query string, args ...int
 }
 
 // Query logs its params and calls the underlying driver Query method.
-func (d *DebugDriver) Query(ctx context.Context, query string, args, v interface{}) error {
+func (d *DebugDriver) Query(ctx context.Context, query string, args, v any) error {
 	d.log(ctx, fmt.Sprintf("driver.Query: query=%v args=%v", query, args))
 	return d.Driver.Query(ctx, query, args, v)
 }
 
 // QueryContext logs its params and calls the underlying driver QueryContext method if it is supported.
-func (d *DebugDriver) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
+func (d *DebugDriver) QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error) {
 	drv, ok := d.Driver.(interface {
-		QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
+		QueryContext(context.Context, string, ...any) (*sql.Rows, error)
 	})
 	if !ok {
 		return nil, fmt.Errorf("Driver.QueryContext is not supported")
@@ -153,22 +153,22 @@ func (d *DebugDriver) BeginTx(ctx context.Context, opts *sql.TxOptions) (Tx, err
 
 // DebugTx is a transaction implementation that logs all transaction operations.
 type DebugTx struct {
-	Tx                                        // underlying transaction.
-	id  string                                // transaction logging id.
-	log func(context.Context, ...interface{}) // log function. defaults to fmt.Println.
-	ctx context.Context                       // underlying transaction context.
+	Tx                                // underlying transaction.
+	id  string                        // transaction logging id.
+	log func(context.Context, ...any) // log function. defaults to fmt.Println.
+	ctx context.Context               // underlying transaction context.
 }
 
 // Exec logs its params and calls the underlying transaction Exec method.
-func (d *DebugTx) Exec(ctx context.Context, query string, args, v interface{}) error {
+func (d *DebugTx) Exec(ctx context.Context, query string, args, v any) error {
 	d.log(ctx, fmt.Sprintf("Tx(%s).Exec: query=%v args=%v", d.id, query, args))
 	return d.Tx.Exec(ctx, query, args, v)
 }
 
 // ExecContext logs its params and calls the underlying transaction ExecContext method if it is supported.
-func (d *DebugTx) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
+func (d *DebugTx) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) {
 	drv, ok := d.Tx.(interface {
-		ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
+		ExecContext(context.Context, string, ...any) (sql.Result, error)
 	})
 	if !ok {
 		return nil, fmt.Errorf("Tx.ExecContext is not supported")
@@ -178,15 +178,15 @@ func (d *DebugTx) ExecContext(ctx context.Context, query string, args ...interfa
 }
 
 // Query logs its params and calls the underlying transaction Query method.
-func (d *DebugTx) Query(ctx context.Context, query string, args, v interface{}) error {
+func (d *DebugTx) Query(ctx context.Context, query string, args, v any) error {
 	d.log(ctx, fmt.Sprintf("Tx(%s).Query: query=%v args=%v", d.id, query, args))
 	return d.Tx.Query(ctx, query, args, v)
 }
 
 // QueryContext logs its params and calls the underlying transaction QueryContext method if it is supported.
-func (d *DebugTx) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
+func (d *DebugTx) QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error) {
 	drv, ok := d.Tx.(interface {
-		QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
+		QueryContext(context.Context, string, ...any) (*sql.Rows, error)
 	})
 	if !ok {
 		return nil, fmt.Errorf("Tx.QueryContext is not supported")

dialect/gremlin/client.go

@@ -72,6 +72,6 @@ func (c Client) Query(ctx context.Context, query string) (*Response, error) {
 }
 
 // Queryf formats a query string and invokes Query.
-func (c Client) Queryf(ctx context.Context, format string, args ...interface{}) (*Response, error) {
+func (c Client) Queryf(ctx context.Context, format string, args ...any) (*Response, error) {
 	return c.Query(ctx, fmt.Sprintf(format, args...))
 }

dialect/gremlin/config_test.go

@@ -149,6 +149,6 @@ func TestExpandOrdering(t *testing.T) {
 	}
 	c, err := cfg.Build(WithInterceptor(interceptor))
 	require.NoError(t, err)
-	req := NewEvalRequest("g.V().hasLabel($1)", WithBindings(map[string]interface{}{"$1": "user"}))
+	req := NewEvalRequest("g.V().hasLabel($1)", WithBindings(map[string]any{"$1": "user"}))
 	_, _ = c.Do(context.Background(), req)
 }

dialect/gremlin/driver.go

@@ -27,14 +27,14 @@ func NewDriver(c *Client) *Driver {
 func (Driver) Dialect() string { return dialect.Gremlin }
 
 // Exec implements the dialect.Exec method.
-func (c *Driver) Exec(ctx context.Context, query string, args, v interface{}) error {
+func (c *Driver) Exec(ctx context.Context, query string, args, v any) error {
 	vr, ok := v.(*Response)
 	if !ok {
 		return fmt.Errorf("dialect/gremlin: invalid type %T. expect *gremlin.Response", v)
 	}
 	bindings, ok := args.(dsl.Bindings)
 	if !ok {
-		return fmt.Errorf("dialect/gremlin: invalid type %T. expect map[string]interface{} for bindings", args)
+		return fmt.Errorf("dialect/gremlin: invalid type %T. expect map[string]any for bindings", args)
 	}
 	res, err := c.Do(ctx, NewEvalRequest(query, WithBindings(bindings)))
 	if err != nil {
@@ -45,7 +45,7 @@ func (c *Driver) Exec(ctx context.Context, query string, args, v interface{}) er
 }
 
 // Query implements the dialect.Query method.
-func (c *Driver) Query(ctx context.Context, query string, args, v interface{}) error {
+func (c *Driver) Query(ctx context.Context, query string, args, v any) error {
 	return c.Exec(ctx, query, args, v)
 }
 

dialect/gremlin/encoding/graphson/bench_test.go

@@ -66,7 +66,7 @@ func BenchmarkMarshalInterface(b *testing.B) {
 		b.Fatal(err)
 	}
 
-	var obj interface{}
+	var obj any
 	if err = jsoniter.Unmarshal(data, &obj); err != nil {
 		b.Fatal(err)
 	}
@@ -87,7 +87,7 @@ func BenchmarkUnmarshalInterface(b *testing.B) {
 		b.Fatal(err)
 	}
 
-	var obj interface{}
+	var obj any
 
 	b.ResetTimer()
 	for n := 0; n < b.N; n++ {

dialect/gremlin/encoding/graphson/decode.go

@@ -18,19 +18,19 @@ type decodeExtension struct {
 
 // Unmarshal parses the graphson encoded data and stores the result
 // in the value pointed to by v.
-func Unmarshal(data []byte, v interface{}) error {
+func Unmarshal(data []byte, v any) error {
 	return config.Unmarshal(data, v)
 }
 
 // UnmarshalFromString parses the graphson encoded str and stores the result
 // in the value pointed to by v.
-func UnmarshalFromString(str string, v interface{}) error {
+func UnmarshalFromString(str string, v any) error {
 	return config.UnmarshalFromString(str, v)
 }
 
 // Decoder defines a graphson decoder.
 type Decoder interface {
-	Decode(interface{}) error
+	Decode(any) error
 }
 
 // NewDecoder create a graphson decoder.

dialect/gremlin/encoding/graphson/encode.go

@@ -17,18 +17,18 @@ type encodeExtension struct {
 }
 
 // Marshal returns the graphson encoding of v.
-func Marshal(v interface{}) ([]byte, error) {
+func Marshal(v any) ([]byte, error) {
 	return config.Marshal(v)
 }
 
 // MarshalToString returns the graphson encoding of v as string.
-func MarshalToString(v interface{}) (string, error) {
+func MarshalToString(v any) (string, error) {
 	return config.MarshalToString(v)
 }
 
 // Encoder defines a graphson encoder.
 type Encoder interface {
-	Encode(interface{}) error
+	Encode(any) error
 }
 
 // NewEncoder create a graphson encoder.

dialect/gremlin/encoding/graphson/error.go

@@ -12,16 +12,16 @@ import (
 )
 
 // EncoderOfError returns a value encoder which always fails to encode.
-func (encodeExtension) EncoderOfError(format string, args ...interface{}) jsoniter.ValEncoder {
+func (encodeExtension) EncoderOfError(format string, args ...any) jsoniter.ValEncoder {
 	return decoratorOfError(format, args...)
 }
 
 // DecoderOfError returns a value decoder which always fails to decode.
-func (decodeExtension) DecoderOfError(format string, args ...interface{}) jsoniter.ValDecoder {
+func (decodeExtension) DecoderOfError(format string, args ...any) jsoniter.ValDecoder {
 	return decoratorOfError(format, args...)
 }
 
-func decoratorOfError(format string, args ...interface{}) errorCodec {
+func decoratorOfError(format string, args ...any) errorCodec {
 	err := fmt.Errorf(format, args...)
 	return errorCodec{err}
 }

dialect/gremlin/encoding/graphson/interface.go

@@ -55,7 +55,7 @@ func (dec efaceDecoder) decode(ptr unsafe.Pointer, iter *jsoniter.Iterator) {
 	it := config.BorrowIterator(data)
 	defer config.ReturnIterator(it)
 
-	var val interface{}
+	var val any
 	if rtype != nil {
 		val = rtype.New()
 		it.ReadVal(val)
@@ -120,30 +120,30 @@ func (efaceDecoder) reflectType(typ Type) reflect2.Type {
 }
 
 func (efaceDecoder) reflectSlice(data []byte) (reflect2.Type, error) {
-	var elem interface{}
-	if err := Unmarshal(data, &[...]*interface{}{&elem}); err != nil {
+	var elem any
+	if err := Unmarshal(data, &[...]*any{&elem}); err != nil {
 		return nil, fmt.Errorf("cannot read first list element: %w", err)
 	}
 
 	if elem == nil {
-		return reflect2.TypeOf([]interface{}{}), nil
+		return reflect2.TypeOf([]any{}), nil
 	}
 
 	sliceType := reflect.SliceOf(reflect.TypeOf(elem))
 	return reflect2.Type2(sliceType), nil
 }
 
 func (efaceDecoder) reflectMap(data []byte) (reflect2.Type, error) {
-	var key, elem interface{}
+	var key, elem any
 	if err := Unmarshal(
 		bytes.Replace(data, []byte(mapType), []byte(listType), 1),
-		&[...]*interface{}{&key, &elem},
+		&[...]*any{&key, &elem},
 	); err != nil {
 		return nil, fmt.Errorf("cannot unmarshal first map item: %w", err)
 	}
 
 	if key == nil {
-		return reflect2.TypeOf(map[interface{}]interface{}{}), nil
+		return reflect2.TypeOf(map[any]any{}), nil
 	} else if elem == nil {
 		return nil, errors.New("expect map element, but found only key")
 	}