ci: add gofumpt check in reviewdog (go-gorm#4973)

.github/workflows/reviewdog.yml

@@ -9,3 +9,14 @@ jobs:
         uses: actions/checkout@v2
       - name: golangci-lint
         uses: reviewdog/action-golangci-lint@v2
+
+      - name: Setup reviewdog
+        uses: reviewdog/action-setup@v1
+
+      - name: gofumpt -s with reviewdog
+        env:
+          REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          go install mvdan.cc/[email protected]
+          gofumpt -e -d . | \
+          reviewdog -name="gofumpt" -f=diff -f.diff.strip=0 -reporter=github-pr-review

callbacks/helper.go

@@ -12,7 +12,7 @@ func ConvertMapToValuesForCreate(stmt *gorm.Statement, mapValue map[string]inter
 	values.Columns = make([]clause.Column, 0, len(mapValue))
 	selectColumns, restricted := stmt.SelectAndOmitColumns(true, false)
 
-	var keys = make([]string, 0, len(mapValue))
+	keys := make([]string, 0, len(mapValue))
 	for k := range mapValue {
 		keys = append(keys, k)
 	}
@@ -40,9 +40,7 @@ func ConvertMapToValuesForCreate(stmt *gorm.Statement, mapValue map[string]inter
 
 // ConvertSliceOfMapToValuesForCreate convert slice of map to values
 func ConvertSliceOfMapToValuesForCreate(stmt *gorm.Statement, mapValues []map[string]interface{}) (values clause.Values) {
-	var (
-		columns = make([]string, 0, len(mapValues))
-	)
+	columns := make([]string, 0, len(mapValues))
 
 	// when the length of mapValues is zero,return directly here
 	// no need to call stmt.SelectAndOmitColumns method

callbacks/update.go

@@ -162,7 +162,7 @@ func ConvertToAssignments(stmt *gorm.Statement) (set clause.Set) {
 			if size := stmt.ReflectValue.Len(); size > 0 {
 				var primaryKeyExprs []clause.Expression
 				for i := 0; i < size; i++ {
-					var exprs = make([]clause.Expression, len(stmt.Schema.PrimaryFields))
+					exprs := make([]clause.Expression, len(stmt.Schema.PrimaryFields))
 					var notZero bool
 					for idx, field := range stmt.Schema.PrimaryFields {
 						value, isZero := field.ValueOf(stmt.ReflectValue.Index(i))
@@ -242,7 +242,7 @@ func ConvertToAssignments(stmt *gorm.Statement) (set clause.Set) {
 			}
 		}
 	default:
-		var updatingSchema = stmt.Schema
+		updatingSchema := stmt.Schema
 		if !updatingValue.CanAddr() || stmt.Dest != stmt.Model {
 			// different schema
 			updatingStmt := &gorm.Statement{DB: stmt.DB}

clause/benchmarks_test.go

@@ -32,7 +32,8 @@ func BenchmarkComplexSelect(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		stmt := gorm.Statement{DB: db, Table: user.Table, Schema: user, Clauses: map[string]clause.Clause{}}
 		clauses := []clause.Interface{
-			clause.Select{}, clause.From{},
+			clause.Select{},
+			clause.From{},
 			clause.Where{Exprs: []clause.Expression{
 				clause.Eq{Column: clause.PrimaryColumn, Value: "1"},
 				clause.Gt{Column: "age", Value: 18},

clause/group_by_test.go

@@ -18,7 +18,8 @@ func TestGroupBy(t *testing.T) {
 				Columns: []clause.Column{{Name: "role"}},
 				Having:  []clause.Expression{clause.Eq{"role", "admin"}},
 			}},
-			"SELECT * FROM `users` GROUP BY `role` HAVING `role` = ?", []interface{}{"admin"},
+			"SELECT * FROM `users` GROUP BY `role` HAVING `role` = ?",
+			[]interface{}{"admin"},
 		},
 		{
 			[]clause.Interface{clause.Select{}, clause.From{}, clause.GroupBy{
@@ -28,7 +29,8 @@ func TestGroupBy(t *testing.T) {
 				Columns: []clause.Column{{Name: "gender"}},
 				Having:  []clause.Expression{clause.Neq{"gender", "U"}},
 			}},
-			"SELECT * FROM `users` GROUP BY `role`,`gender` HAVING `role` = ? AND `gender` <> ?", []interface{}{"admin", "U"},
+			"SELECT * FROM `users` GROUP BY `role`,`gender` HAVING `role` = ? AND `gender` <> ?",
+			[]interface{}{"admin", "U"},
 		},
 	}
 

clause/order_by_test.go

@@ -45,7 +45,8 @@ func TestOrderBy(t *testing.T) {
 					Expression: clause.Expr{SQL: "FIELD(id, ?)", Vars: []interface{}{[]int{1, 2, 3}}, WithoutParentheses: true},
 				},
 			},
-			"SELECT * FROM `users` ORDER BY FIELD(id, ?,?,?)", []interface{}{1, 2, 3},
+			"SELECT * FROM `users` ORDER BY FIELD(id, ?,?,?)",
+			[]interface{}{1, 2, 3},
 		},
 	}
 

clause/set_test.go

@@ -20,15 +20,17 @@ func TestSet(t *testing.T) {
 				clause.Update{},
 				clause.Set([]clause.Assignment{{clause.PrimaryColumn, 1}}),
 			},
-			"UPDATE `users` SET `users`.`id`=?", []interface{}{1},
+			"UPDATE `users` SET `users`.`id`=?",
+			[]interface{}{1},
 		},
 		{
 			[]clause.Interface{
 				clause.Update{},
 				clause.Set([]clause.Assignment{{clause.PrimaryColumn, 1}}),
 				clause.Set([]clause.Assignment{{clause.Column{Name: "name"}, "jinzhu"}}),
 			},
-			"UPDATE `users` SET `name`=?", []interface{}{"jinzhu"},
+			"UPDATE `users` SET `name`=?",
+			[]interface{}{"jinzhu"},
 		},
 	}
 

clause/values_test.go

@@ -21,7 +21,8 @@ func TestValues(t *testing.T) {
 					Values:  [][]interface{}{{"jinzhu", 18}, {"josh", 1}},
 				},
 			},
-			"INSERT INTO `users` (`name`,`age`) VALUES (?,?),(?,?)", []interface{}{"jinzhu", 18, "josh", 1},
+			"INSERT INTO `users` (`name`,`age`) VALUES (?,?),(?,?)",
+			[]interface{}{"jinzhu", 18, "josh", 1},
 		},
 	}
 

clause/where_test.go

@@ -17,47 +17,54 @@ func TestWhere(t *testing.T) {
 			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
 				Exprs: []clause.Expression{clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}, clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})},
 			}},
-			"SELECT * FROM `users` WHERE `users`.`id` = ? AND `age` > ? OR `name` <> ?", []interface{}{"1", 18, "jinzhu"},
+			"SELECT * FROM `users` WHERE `users`.`id` = ? AND `age` > ? OR `name` <> ?",
+			[]interface{}{"1", 18, "jinzhu"},
 		},
 		{
 			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
 				Exprs: []clause.Expression{clause.Or(clause.Neq{Column: "name", Value: "jinzhu"}), clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}},
 			}},
-			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ? AND `age` > ?", []interface{}{"1", "jinzhu", 18},
+			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ? AND `age` > ?",
+			[]interface{}{"1", "jinzhu", 18},
 		},
 		{
 			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
 				Exprs: []clause.Expression{clause.Or(clause.Neq{Column: "name", Value: "jinzhu"}), clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}},
 			}},
-			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ? AND `age` > ?", []interface{}{"1", "jinzhu", 18},
+			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ? AND `age` > ?",
+			[]interface{}{"1", "jinzhu", 18},
 		},
 		{
 			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
 				Exprs: []clause.Expression{clause.Or(clause.Eq{Column: clause.PrimaryColumn, Value: "1"}), clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})},
 			}},
-			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ?", []interface{}{"1", "jinzhu"},
+			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ?",
+			[]interface{}{"1", "jinzhu"},
 		},
 		{
 			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
 				Exprs: []clause.Expression{clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}, clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})},
 			}, clause.Where{
 				Exprs: []clause.Expression{clause.Or(clause.Gt{Column: "score", Value: 100}, clause.Like{Column: "name", Value: "%linus%"})},
 			}},
-			"SELECT * FROM `users` WHERE `users`.`id` = ? AND `age` > ? OR `name` <> ? AND (`score` > ? OR `name` LIKE ?)", []interface{}{"1", 18, "jinzhu", 100, "%linus%"},
+			"SELECT * FROM `users` WHERE `users`.`id` = ? AND `age` > ? OR `name` <> ? AND (`score` > ? OR `name` LIKE ?)",
+			[]interface{}{"1", 18, "jinzhu", 100, "%linus%"},
 		},
 		{
 			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
 				Exprs: []clause.Expression{clause.Not(clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}), clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})},
 			}, clause.Where{
 				Exprs: []clause.Expression{clause.Or(clause.Not(clause.Gt{Column: "score", Value: 100}), clause.Like{Column: "name", Value: "%linus%"})},
 			}},
-			"SELECT * FROM `users` WHERE (`users`.`id` <> ? AND `age` <= ?) OR `name` <> ? AND (`score` <= ? OR `name` LIKE ?)", []interface{}{"1", 18, "jinzhu", 100, "%linus%"},
+			"SELECT * FROM `users` WHERE (`users`.`id` <> ? AND `age` <= ?) OR `name` <> ? AND (`score` <= ? OR `name` LIKE ?)",
+			[]interface{}{"1", 18, "jinzhu", 100, "%linus%"},
 		},
 		{
 			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
 				Exprs: []clause.Expression{clause.And(clause.Eq{Column: "age", Value: 18}, clause.Or(clause.Neq{Column: "name", Value: "jinzhu"}))},
 			}},
-			"SELECT * FROM `users` WHERE (`age` = ? OR `name` <> ?)", []interface{}{18, "jinzhu"},
+			"SELECT * FROM `users` WHERE (`age` = ? OR `name` <> ?)",
+			[]interface{}{18, "jinzhu"},
 		},
 	}
 

clause/with.go

@@ -1,4 +1,3 @@
 package clause
 
-type With struct {
-}
+type With struct{}

logger/sql.go

@@ -32,7 +32,7 @@ var convertibleTypes = []reflect.Type{reflect.TypeOf(time.Time{}), reflect.TypeO
 
 func ExplainSQL(sql string, numericPlaceholder *regexp.Regexp, escaper string, avars ...interface{}) string {
 	var convertParams func(interface{}, int)
-	var vars = make([]string, len(avars))
+	vars := make([]string, len(avars))
 
 	convertParams = func(v interface{}, idx int) {
 		switch v := v.(type) {

migrator/migrator.go

@@ -541,7 +541,7 @@ func (m Migrator) CreateConstraint(value interface{}, name string) error {
 		}
 
 		if constraint != nil {
-			var vars = []interface{}{clause.Table{Name: table}}
+			vars := []interface{}{clause.Table{Name: table}}
 			if stmt.TableExpr != nil {
 				vars[0] = stmt.TableExpr
 			}

schema/callbacks_test.go

@@ -9,8 +9,7 @@ import (
 	"gorm.io/gorm/schema"
 )
 
-type UserWithCallback struct {
-}
+type UserWithCallback struct{}
 
 func (UserWithCallback) BeforeSave(*gorm.DB) error {
 	return nil

schema/check.go

@@ -5,10 +5,8 @@ import (
 	"strings"
 )
 
-var (
-	// reg match english letters and midline
-	regEnLetterAndMidline = regexp.MustCompile("^[A-Za-z-_]+$")
-)
+// reg match english letters and midline
+var regEnLetterAndMidline = regexp.MustCompile("^[A-Za-z-_]+$")
 
 type Check struct {
 	Name       string
@@ -18,7 +16,7 @@ type Check struct {
 
 // ParseCheckConstraints parse schema check constraints
 func (schema *Schema) ParseCheckConstraints() map[string]Check {
-	var checks = map[string]Check{}
+	checks := map[string]Check{}
 	for _, field := range schema.FieldsByDBName {
 		if chk := field.TagSettings["CHECK"]; chk != "" {
 			names := strings.Split(chk, ",")

schema/field.go

@@ -398,8 +398,8 @@ func (schema *Schema) ParseField(fieldStruct reflect.StructField) *Field {
 					ef.TagSettings[k] = v
 				}
 			}
-		case reflect.Invalid, reflect.Uintptr, reflect.Array, reflect.Chan,          reflect.Func,      reflect.Interface,
-		     reflect.Map,     reflect.Ptr,     reflect.Slice, reflect.UnsafePointer, reflect.Complex64, reflect.Complex128:
+		case reflect.Invalid, reflect.Uintptr, reflect.Array, reflect.Chan, reflect.Func, reflect.Interface,
+			reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer, reflect.Complex64, reflect.Complex128:
 			schema.err = fmt.Errorf("invalid embedded struct for %s's field %s, should be struct, but got %v", field.Schema.Name, field.Name, field.FieldType)
 		}
 	}

schema/field_test.go

@@ -261,64 +261,66 @@ func TestParseFieldWithPermission(t *testing.T) {
 	}
 }
 
-type ID int64
-type INT int
-type INT8 int8
-type INT16 int16
-type INT32 int32
-type INT64 int64
-type UINT uint
-type UINT8 uint8
-type UINT16 uint16
-type UINT32 uint32
-type UINT64 uint64
-type FLOAT32 float32
-type FLOAT64 float64
-type BOOL bool
-type STRING string
-type TypeAlias struct {
-	ID
-	INT     `gorm:"column:fint"`
-	INT8    `gorm:"column:fint8"`
-	INT16   `gorm:"column:fint16"`
-	INT32   `gorm:"column:fint32"`
-	INT64   `gorm:"column:fint64"`
-	UINT    `gorm:"column:fuint"`
-	UINT8   `gorm:"column:fuint8"`
-	UINT16  `gorm:"column:fuint16"`
-	UINT32  `gorm:"column:fuint32"`
-	UINT64  `gorm:"column:fuint64"`
-	FLOAT32 `gorm:"column:ffloat32"`
-	FLOAT64 `gorm:"column:ffloat64"`
-	BOOL    `gorm:"column:fbool"`
-	STRING  `gorm:"column:fstring"`
-}
+type (
+	ID        int64
+	INT       int
+	INT8      int8
+	INT16     int16
+	INT32     int32
+	INT64     int64
+	UINT      uint
+	UINT8     uint8
+	UINT16    uint16
+	UINT32    uint32
+	UINT64    uint64
+	FLOAT32   float32
+	FLOAT64   float64
+	BOOL      bool
+	STRING    string
+	TypeAlias struct {
+		ID
+		INT     `gorm:"column:fint"`
+		INT8    `gorm:"column:fint8"`
+		INT16   `gorm:"column:fint16"`
+		INT32   `gorm:"column:fint32"`
+		INT64   `gorm:"column:fint64"`
+		UINT    `gorm:"column:fuint"`
+		UINT8   `gorm:"column:fuint8"`
+		UINT16  `gorm:"column:fuint16"`
+		UINT32  `gorm:"column:fuint32"`
+		UINT64  `gorm:"column:fuint64"`
+		FLOAT32 `gorm:"column:ffloat32"`
+		FLOAT64 `gorm:"column:ffloat64"`
+		BOOL    `gorm:"column:fbool"`
+		STRING  `gorm:"column:fstring"`
+	}
+)
 
-func TestTypeAliasField(t *testing.T){
+func TestTypeAliasField(t *testing.T) {
 	alias, err := schema.Parse(&TypeAlias{}, &sync.Map{}, schema.NamingStrategy{})
 	if err != nil {
 		t.Fatalf("Failed to parse TypeAlias with permission, got error %v", err)
 	}
 
 	fields := []*schema.Field{
-		{Name: "ID",      DBName: "id",       BindNames: []string{"ID"},      DataType: schema.Int   , Creatable: true, Updatable: true, Readable: true, Size: 64, PrimaryKey: true, HasDefaultValue: true, AutoIncrement: true },
-		{Name: "INT",     DBName: "fint",     BindNames: []string{"INT"},     DataType: schema.Int   , Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fint"`},
-		{Name: "INT8",    DBName: "fint8",    BindNames: []string{"INT8"},    DataType: schema.Int   , Creatable: true, Updatable: true, Readable: true, Size: 8,  Tag: `gorm:"column:fint8"`},
-		{Name: "INT16",   DBName: "fint16",   BindNames: []string{"INT16"},   DataType: schema.Int   , Creatable: true, Updatable: true, Readable: true, Size: 16, Tag: `gorm:"column:fint16"`},
-		{Name: "INT32",   DBName: "fint32",   BindNames: []string{"INT32"},   DataType: schema.Int   , Creatable: true, Updatable: true, Readable: true, Size: 32, Tag: `gorm:"column:fint32"`},
-		{Name: "INT64",   DBName: "fint64",   BindNames: []string{"INT64"},   DataType: schema.Int   , Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fint64"`},
-		{Name: "UINT",    DBName: "fuint",    BindNames: []string{"UINT"},    DataType: schema.Uint  , Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fuint"`},
-		{Name: "UINT8",   DBName: "fuint8",   BindNames: []string{"UINT8"},   DataType: schema.Uint  , Creatable: true, Updatable: true, Readable: true, Size: 8,  Tag: `gorm:"column:fuint8"`},
-		{Name: "UINT16",  DBName: "fuint16",  BindNames: []string{"UINT16"},  DataType: schema.Uint  , Creatable: true, Updatable: true, Readable: true, Size: 16, Tag: `gorm:"column:fuint16"`},
-		{Name: "UINT32",  DBName: "fuint32",  BindNames: []string{"UINT32"},  DataType: schema.Uint  , Creatable: true, Updatable: true, Readable: true, Size: 32, Tag: `gorm:"column:fuint32"`},
-		{Name: "UINT64",  DBName: "fuint64",  BindNames: []string{"UINT64"},  DataType: schema.Uint  , Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fuint64"`},
-		{Name: "FLOAT32", DBName: "ffloat32", BindNames: []string{"FLOAT32"}, DataType: schema.Float , Creatable: true, Updatable: true, Readable: true, Size: 32, Tag: `gorm:"column:ffloat32"`},
-		{Name: "FLOAT64", DBName: "ffloat64", BindNames: []string{"FLOAT64"}, DataType: schema.Float , Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:ffloat64"`},
-		{Name: "BOOL",    DBName: "fbool",    BindNames: []string{"BOOL"},    DataType: schema.Bool  , Creatable: true, Updatable: true, Readable: true, Tag: `gorm:"column:fbool"`},
-		{Name: "STRING",  DBName: "fstring",  BindNames: []string{"STRING"},  DataType: schema.String, Creatable: true, Updatable: true, Readable: true, Tag: `gorm:"column:fstring"`},
+		{Name: "ID", DBName: "id", BindNames: []string{"ID"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 64, PrimaryKey: true, HasDefaultValue: true, AutoIncrement: true},
+		{Name: "INT", DBName: "fint", BindNames: []string{"INT"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fint"`},
+		{Name: "INT8", DBName: "fint8", BindNames: []string{"INT8"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 8, Tag: `gorm:"column:fint8"`},
+		{Name: "INT16", DBName: "fint16", BindNames: []string{"INT16"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 16, Tag: `gorm:"column:fint16"`},
+		{Name: "INT32", DBName: "fint32", BindNames: []string{"INT32"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 32, Tag: `gorm:"column:fint32"`},
+		{Name: "INT64", DBName: "fint64", BindNames: []string{"INT64"}, DataType: schema.Int, Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fint64"`},
+		{Name: "UINT", DBName: "fuint", BindNames: []string{"UINT"}, DataType: schema.Uint, Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fuint"`},
+		{Name: "UINT8", DBName: "fuint8", BindNames: []string{"UINT8"}, DataType: schema.Uint, Creatable: true, Updatable: true, Readable: true, Size: 8, Tag: `gorm:"column:fuint8"`},
+		{Name: "UINT16", DBName: "fuint16", BindNames: []string{"UINT16"}, DataType: schema.Uint, Creatable: true, Updatable: true, Readable: true, Size: 16, Tag: `gorm:"column:fuint16"`},
+		{Name: "UINT32", DBName: "fuint32", BindNames: []string{"UINT32"}, DataType: schema.Uint, Creatable: true, Updatable: true, Readable: true, Size: 32, Tag: `gorm:"column:fuint32"`},
+		{Name: "UINT64", DBName: "fuint64", BindNames: []string{"UINT64"}, DataType: schema.Uint, Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:fuint64"`},
+		{Name: "FLOAT32", DBName: "ffloat32", BindNames: []string{"FLOAT32"}, DataType: schema.Float, Creatable: true, Updatable: true, Readable: true, Size: 32, Tag: `gorm:"column:ffloat32"`},
+		{Name: "FLOAT64", DBName: "ffloat64", BindNames: []string{"FLOAT64"}, DataType: schema.Float, Creatable: true, Updatable: true, Readable: true, Size: 64, Tag: `gorm:"column:ffloat64"`},
+		{Name: "BOOL", DBName: "fbool", BindNames: []string{"BOOL"}, DataType: schema.Bool, Creatable: true, Updatable: true, Readable: true, Tag: `gorm:"column:fbool"`},
+		{Name: "STRING", DBName: "fstring", BindNames: []string{"STRING"}, DataType: schema.String, Creatable: true, Updatable: true, Readable: true, Tag: `gorm:"column:fstring"`},
 	}
 
 	for _, f := range fields {
 		checkSchemaField(t, alias, f, func(f *schema.Field) {})
 	}
-}
+}

schema/index.go

@@ -27,7 +27,7 @@ type IndexOption struct {
 
 // ParseIndexes parse schema indexes
 func (schema *Schema) ParseIndexes() map[string]Index {
-	var indexes = map[string]Index{}
+	indexes := map[string]Index{}
 
 	for _, field := range schema.Fields {
 		if field.TagSettings["INDEX"] != "" || field.TagSettings["UNIQUEINDEX"] != "" {

schema/model_test.go

@@ -26,9 +26,11 @@ type User struct {
 	Active    *bool
 }
 
-type mytime time.Time
-type myint int
-type mybool = bool
+type (
+	mytime time.Time
+	myint  int
+	mybool = bool
+)
 
 type AdvancedDataTypeUser struct {
 	ID           sql.NullInt64