diff --git a/Makefile b/Makefile
index ca0e3e6b6a059..15c4f81ddb793 100644
--- a/Makefile
+++ b/Makefile
@@ -20,8 +20,9 @@ GOVERALLS := goveralls
 ARCH      := "`uname -s`"
 LINUX     := "Linux"
 MAC       := "Darwin"
-PACKAGES  := $$(go list ./...| grep -vE 'vendor')
-FILES     := $$(find . -name '*.go' | grep -vE 'vendor')
+PACKAGES  := $$(go list ./...| grep -vE "vendor")
+FILES     := $$(find . -name "*.go" | grep -vE "vendor")
+TOPDIRS   := $$(ls -d */ | grep -vE "vendor")
 
 LDFLAGS += -X "github.com/pingcap/tidb/util/printer.TiDBBuildTS=$(shell date -u '+%Y-%m-%d %I:%M:%S')"
 LDFLAGS += -X "github.com/pingcap/tidb/util/printer.TiDBGitHash=$(shell git rev-parse HEAD)"
@@ -74,9 +75,8 @@ check:
 	go get github.com/golang/lint/golint
 
 	@echo "vet"
-	@ go tool vet $(FILES) 2>&1 | awk '{print} END{if(NR>0) {exit 1}}'
-	@echo "vet --shadow"
-	@ go tool vet --shadow $(FILES) 2>&1 | awk '{print} END{if(NR>0) {exit 1}}'
+	@ go tool vet -all -shadow $(TOPDIRS) 2>&1 | awk '{print} END{if(NR>0) {exit 1}}'
+	@ go tool vet -all -shadow *.go 2>&1 | awk '{print} END{if(NR>0) {exit 1}}'
 	@echo "golint"
 	@ golint ./... 2>&1 | grep -vE 'context\.Context|LastInsertId|NewLexer|\.pb\.go' | awk '{print} END{if(NR>0) {exit 1}}'
 	@echo "gofmt (simplify)"
diff --git a/bootstrap.go b/bootstrap.go
index 3796f7880df5b..248795c37ad7d 100644
--- a/bootstrap.go
+++ b/bootstrap.go
@@ -451,13 +451,14 @@ func upgradeToVer12(s Session) {
 		user := row.Data[0].GetString()
 		host := row.Data[1].GetString()
 		pass := row.Data[2].GetString()
-		newpass, err := oldPasswordUpgrade(pass)
+		var newPass string
+		newPass, err = oldPasswordUpgrade(pass)
 		if err != nil {
 			log.Fatal(err)
 			return
 		}
-		sql := fmt.Sprintf(`UPDATE mysql.user set password = "%s" where user="%s" and host="%s"`, newpass, user, host)
-		sqls = append(sqls, sql)
+		updateSQL := fmt.Sprintf(`UPDATE mysql.user set password = "%s" where user="%s" and host="%s"`, newPass, user, host)
+		sqls = append(sqls, updateSQL)
 		row, err = r.Next()
 	}
 
diff --git a/cmd/benchfilesort/main.go b/cmd/benchfilesort/main.go
index 9d5dfa9e21bf7..0e63e87c07551 100644
--- a/cmd/benchfilesort/main.go
+++ b/cmd/benchfilesort/main.go
@@ -417,9 +417,9 @@ func main() {
 	flag.Parse()
 
 	if len(os.Args) == 1 {
-		fmt.Println("Usage:\n")
-		fmt.Println("\tbenchfilesort command [arguments]\n")
-		fmt.Println("The commands are:\n")
+		fmt.Printf("Usage:\n\n")
+		fmt.Printf("\tbenchfilesort command [arguments]\n\n")
+		fmt.Printf("The commands are:\n\n")
 		fmt.Println("\tgen\t", "generate rows")
 		fmt.Println("\trun\t", "run tests")
 		fmt.Println("")
diff --git a/ddl/column.go b/ddl/column.go
index 94d145ac49fe5..9daa84cdc3a51 100644
--- a/ddl/column.go
+++ b/ddl/column.go
@@ -150,7 +150,8 @@ func (d *ddl) onAddColumn(t *meta.Meta, job *model.Job) (ver int64, _ error) {
 	case model.StateWriteReorganization:
 		// reorganization -> public
 		// Get the current version for reorganization if we don't have it.
-		reorgInfo, err := d.getReorgInfo(t, job)
+		var reorgInfo *reorgInfo
+		reorgInfo, err = d.getReorgInfo(t, job)
 		if err != nil || reorgInfo.first {
 			// If we run reorg firstly, we should update the job snapshot version
 			// and then run the reorg next time.
@@ -233,7 +234,8 @@ func (d *ddl) onDropColumn(t *meta.Meta, job *model.Job) (ver int64, _ error) {
 		ver, err = updateTableInfo(t, job, tblInfo, originalState)
 	case model.StateDeleteReorganization:
 		// reorganization -> absent
-		reorgInfo, err := d.getReorgInfo(t, job)
+		var reorgInfo *reorgInfo
+		reorgInfo, err = d.getReorgInfo(t, job)
 		if err != nil || reorgInfo.first {
 			// If we run reorg firstly, we should update the job snapshot version
 			// and then run the reorg next time.
diff --git a/ddl/ddl_api.go b/ddl/ddl_api.go
index 631488139944a..aaaee8f13cbe1 100644
--- a/ddl/ddl_api.go
+++ b/ddl/ddl_api.go
@@ -889,7 +889,7 @@ func (d *ddl) AddColumn(ctx context.Context, ti ast.Ident, spec *ast.AlterTableS
 				referableColNames[col.Name.L] = struct{}{}
 			}
 			_, dependColNames := findDependedColumnNames(spec.NewColumn)
-			if err := columnNamesCover(referableColNames, dependColNames); err != nil {
+			if err = columnNamesCover(referableColNames, dependColNames); err != nil {
 				return errors.Trace(err)
 			}
 		}
@@ -1158,7 +1158,7 @@ func (d *ddl) getModifiableColumnJob(ctx context.Context, ident ast.Ident, origi
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	if err := setDefaultAndComment(ctx, newCol, spec.NewColumn.Options); err != nil {
+	if err = setDefaultAndComment(ctx, newCol, spec.NewColumn.Options); err != nil {
 		return nil, errors.Trace(err)
 	}
 
@@ -1261,12 +1261,12 @@ func (d *ddl) AlterColumn(ctx context.Context, ident ast.Ident, spec *ast.AlterT
 	}
 
 	// Clean the NoDefaultValueFlag value.
-	col.Flag &= (^uint(mysql.NoDefaultValueFlag))
+	col.Flag &= ^uint(mysql.NoDefaultValueFlag)
 	if len(spec.NewColumn.Options) == 0 {
 		col.DefaultValue = nil
 		setNoDefaultValueFlag(col, false)
 	} else {
-		err := setDefaultValue(ctx, col, spec.NewColumn.Options[0])
+		err = setDefaultValue(ctx, col, spec.NewColumn.Options[0])
 		if err != nil {
 			return errors.Trace(err)
 		}
diff --git a/ddl/ddl_db_test.go b/ddl/ddl_db_test.go
index 043c0c55e3d19..619de9543848c 100644
--- a/ddl/ddl_db_test.go
+++ b/ddl/ddl_db_test.go
@@ -698,7 +698,7 @@ LOOP:
 	matchRows(c, rows, [][]interface{}{{count - int64(step)}})
 
 	for i := num; i < num+step; i++ {
-		rows := s.mustQuery(c, "select c4 from t2 where c4 = ?", i)
+		rows = s.mustQuery(c, "select c4 from t2 where c4 = ?", i)
 		matchRows(c, rows, [][]interface{}{{i}})
 	}
 
diff --git a/ddl/foreign_key_test.go b/ddl/foreign_key_test.go
index d44c142e64fe3..19e837dc50073 100644
--- a/ddl/foreign_key_test.go
+++ b/ddl/foreign_key_test.go
@@ -139,7 +139,8 @@ func (s *testForeighKeySuite) TestForeignKey(c *C) {
 		}
 		mu.Lock()
 		defer mu.Unlock()
-		t, err := testGetTableWithError(d, s.dbInfo.ID, tblInfo.ID)
+		var t table.Table
+		t, err = testGetTableWithError(d, s.dbInfo.ID, tblInfo.ID)
 		if err != nil {
 			hookErr = errors.Trace(err)
 			return
@@ -178,7 +179,8 @@ func (s *testForeighKeySuite) TestForeignKey(c *C) {
 		}
 		mu.Lock()
 		defer mu.Unlock()
-		t, err := testGetTableWithError(d, s.dbInfo.ID, tblInfo.ID)
+		var t table.Table
+		t, err = testGetTableWithError(d, s.dbInfo.ID, tblInfo.ID)
 		if err != nil {
 			hookErr = errors.Trace(err)
 			return
diff --git a/ddl/index.go b/ddl/index.go
index 80280c8566053..0868772da6a80 100644
--- a/ddl/index.go
+++ b/ddl/index.go
@@ -253,7 +253,8 @@ func (d *ddl) onCreateIndex(t *meta.Meta, job *model.Job) (ver int64, err error)
 		ver, err = updateTableInfo(t, job, tblInfo, originalState)
 	case model.StateWriteReorganization:
 		// reorganization -> public
-		reorgInfo, err := d.getReorgInfo(t, job)
+		var reorgInfo *reorgInfo
+		reorgInfo, err = d.getReorgInfo(t, job)
 		if err != nil || reorgInfo.first {
 			// If we run reorg firstly, we should update the job snapshot version
 			// and then run the reorg next time.
diff --git a/ddl/owner_manager.go b/ddl/owner_manager.go
index 3ecd772116d68..d15d1208b4d77 100644
--- a/ddl/owner_manager.go
+++ b/ddl/owner_manager.go
@@ -184,9 +184,9 @@ func (m *ownerManager) campaignLoop(ctx goctx.Context, etcdSession *concurrency.
 		case <-ctx.Done():
 			// Revoke the session lease.
 			// If revoke takes longer than the ttl, lease is expired anyway.
-			ctx, cancel := goctx.WithTimeout(goctx.Background(),
+			cancelCtx, cancel := goctx.WithTimeout(goctx.Background(),
 				time.Duration(ManagerSessionTTL)*time.Second)
-			_, err = m.etcdCli.Revoke(ctx, etcdSession.Lease())
+			_, err = m.etcdCli.Revoke(cancelCtx, etcdSession.Lease())
 			cancel()
 			log.Infof("[ddl] %s break campaign loop err %v", idInfo, err)
 			return
diff --git a/ddl/schema.go b/ddl/schema.go
index 094e317c3c708..4948f6e371f09 100644
--- a/ddl/schema.go
+++ b/ddl/schema.go
@@ -102,7 +102,8 @@ func (d *ddl) onDropSchema(t *meta.Meta, job *model.Job) (ver int64, _ error) {
 		err = t.UpdateDatabase(dbInfo)
 	case model.StateDeleteOnly:
 		dbInfo.State = model.StateNone
-		tables, err := t.ListTables(job.SchemaID)
+		var tables []*model.TableInfo
+		tables, err = t.ListTables(job.SchemaID)
 		if err != nil {
 			return ver, errors.Trace(err)
 		}
diff --git a/distsql/xeval/eval_control_funcs.go b/distsql/xeval/eval_control_funcs.go
index 770cb4c9a920f..5e647d827ed88 100644
--- a/distsql/xeval/eval_control_funcs.go
+++ b/distsql/xeval/eval_control_funcs.go
@@ -76,7 +76,8 @@ func (e *Evaluator) evalIf(expr *tipb.Expr) (d types.Datum, err error) {
 		return d, errors.Trace(err)
 	}
 	if !child1.IsNull() {
-		x, err := child1.ToBool(e.StatementCtx)
+		var x int64
+		x, err = child1.ToBool(e.StatementCtx)
 		if err != nil {
 			return d, errors.Trace(err)
 		}
diff --git a/distsql/xeval/eval_data_type.go b/distsql/xeval/eval_data_type.go
index e26e08e118322..806de4961cd86 100644
--- a/distsql/xeval/eval_data_type.go
+++ b/distsql/xeval/eval_data_type.go
@@ -58,7 +58,8 @@ func (e *Evaluator) evalColumnRef(val []byte) (types.Datum, error) {
 
 	// TODO: Remove this case.
 	if e.ColVals == nil {
-		d, ok := e.Row[i]
+		var ok bool
+		d, ok = e.Row[i]
 		if !ok {
 			return d, ErrInvalid.Gen("column % x not found", val)
 		}
diff --git a/domain/domain.go b/domain/domain.go
index 698d21467a47e..504da8dcce89a 100644
--- a/domain/domain.go
+++ b/domain/domain.go
@@ -399,7 +399,8 @@ func NewDomain(store kv.Storage, ddlLease time.Duration, statsLease time.Duratio
 
 	if ebd, ok := store.(etcdBackend); ok {
 		if addrs := ebd.EtcdAddrs(); addrs != nil {
-			cli, err := clientv3.New(clientv3.Config{
+			var cli *clientv3.Client
+			cli, err = clientv3.New(clientv3.Config{
 				Endpoints:   addrs,
 				DialTimeout: 5 * time.Second,
 			})
diff --git a/executor/analyze.go b/executor/analyze.go
index 9018d854761ac..d417870fe5558 100644
--- a/executor/analyze.go
+++ b/executor/analyze.go
@@ -240,7 +240,7 @@ func CollectSamplesAndEstimateNDVs(ctx context.Context, e ast.RecordSet, numCols
 			return collectors, pkBuilder, nil
 		}
 		if pkInfo != nil {
-			err := pkBuilder.Iterate(row.Data)
+			err = pkBuilder.Iterate(row.Data)
 			if err != nil {
 				return nil, nil, errors.Trace(err)
 			}
diff --git a/executor/builder.go b/executor/builder.go
index 4fe462e18077b..38ad04ffabc49 100644
--- a/executor/builder.go
+++ b/executor/builder.go
@@ -839,7 +839,7 @@ func (b *executorBuilder) buildTableScanForAnalyze(tblInfo *model.TableInfo, pk
 		cols = append([]*model.ColumnInfo{pk}, cols...)
 	}
 	schema := expression.NewSchema(expression.ColumnInfos2Columns(tblInfo.Name, cols)...)
-	ranges := []types.IntColumnRange{{math.MinInt64, math.MaxInt64}}
+	ranges := []types.IntColumnRange{{LowVal: math.MinInt64, HighVal: math.MaxInt64}}
 	if b.ctx.GetClient().IsRequestTypeSupported(kv.ReqTypeDAG, kv.ReqSubTypeBasic) {
 		e := &TableReaderExecutor{
 			table:     table,
diff --git a/executor/executor.go b/executor/executor.go
index 29153489b597d..9137e7d38b636 100644
--- a/executor/executor.go
+++ b/executor/executor.go
@@ -443,7 +443,11 @@ func (e *SelectionExec) initController() error {
 		}
 		x.ranges = ranges
 	case *XSelectIndexExec:
-		accessCondition, newConds, _, accessInAndEqCount := ranger.DetachIndexScanConditions(newConds, x.index)
+		var (
+			accessCondition    []expression.Expression
+			accessInAndEqCount int
+		)
+		accessCondition, newConds, _, accessInAndEqCount = ranger.DetachIndexScanConditions(newConds, x.index)
 		idxConds, tblConds := ranger.DetachIndexFilterConditions(newConds, x.index.Columns, x.tableInfo)
 		x.indexConditionPBExpr, _, _ = expression.ExpressionsToPB(sc, idxConds, client)
 		tableConditionPBExpr, _, _ := expression.ExpressionsToPB(sc, tblConds, client)
diff --git a/executor/executor_test.go b/executor/executor_test.go
index b277b81348d9a..5da8656dd08fa 100644
--- a/executor/executor_test.go
+++ b/executor/executor_test.go
@@ -404,7 +404,8 @@ func (s *testSuite) TestIssue2612(c *C) {
 	c.Assert(err, IsNil)
 	row, err := rs.Next()
 	c.Assert(err, IsNil)
-	row.Data[0].GetMysqlDuration().String()
+	str := row.Data[0].GetMysqlDuration().String()
+	c.Assert(str, Equals, "-46:09:02")
 }
 
 // TestIssue345 is related with https://github.com/pingcap/tidb/issues/345
@@ -1236,7 +1237,7 @@ func (s *testSuite) TestBuiltin(c *C) {
 		tk.MustExec("create table t (a varchar(255), b int)")
 		for i, d := range data {
 			tk.MustExec(fmt.Sprintf("insert into t values('%s', %d)", d.val, i))
-			result := tk.MustQuery(fmt.Sprintf("select * from t where a %s '%s'", queryOp, d.pattern))
+			result = tk.MustQuery(fmt.Sprintf("select * from t where a %s '%s'", queryOp, d.pattern))
 			if d.result == 1 {
 				rowStr := fmt.Sprintf("%s %d", d.val, i)
 				result.Check(testkit.Rows(rowStr))
diff --git a/executor/merge_join.go b/executor/merge_join.go
index de857524aa183..7b0a3df6033f1 100644
--- a/executor/merge_join.go
+++ b/executor/merge_join.go
@@ -371,7 +371,8 @@ func (e *MergeJoinExec) computeCrossProduct() error {
 	for _, lRow := range e.leftRows {
 		// make up for outer join since we ignored single table conditions previously
 		if e.leftFilter != nil {
-			matched, err := expression.EvalBool(e.leftFilter, lRow.Data, e.ctx)
+			var matched bool
+			matched, err = expression.EvalBool(e.leftFilter, lRow.Data, e.ctx)
 			if err != nil {
 				return errors.Trace(err)
 			}
diff --git a/executor/write.go b/executor/write.go
index d81cb9dbf50a8..d856c62a12ce7 100644
--- a/executor/write.go
+++ b/executor/write.go
@@ -64,9 +64,9 @@ func updateRecord(ctx context.Context, h int64, oldData, newData []types.Datum,
 			if newData[i].IsNull() {
 				return false, errors.Errorf("Column '%v' cannot be null", col.Name.O)
 			}
-			val, err := newData[i].ToInt64(sc)
-			if err != nil {
-				return false, errors.Trace(err)
+			val, errTI := newData[i].ToInt64(sc)
+			if errTI != nil {
+				return false, errors.Trace(errTI)
 			}
 			t.RebaseAutoID(val, true)
 		}
@@ -106,9 +106,9 @@ func updateRecord(ctx context.Context, h int64, oldData, newData []types.Datum,
 	// Fill values into on-update-now fields, only if they are really changed.
 	for i, col := range t.Cols() {
 		if mysql.HasOnUpdateNowFlag(col.Flag) && !modified[i] && !onUpdateSpecified[i] {
-			v, err := expression.GetTimeValue(ctx, expression.CurrentTimestamp, col.Tp, col.Decimal)
-			if err != nil {
-				return false, errors.Trace(err)
+			v, errGT := expression.GetTimeValue(ctx, expression.CurrentTimestamp, col.Tp, col.Decimal)
+			if errGT != nil {
+				return false, errors.Trace(errGT)
 			}
 			newData[i] = v
 		}
diff --git a/expression/builtin_cast.go b/expression/builtin_cast.go
index ec857584e6f5c..2393b446c2e94 100644
--- a/expression/builtin_cast.go
+++ b/expression/builtin_cast.go
@@ -367,7 +367,8 @@ func (b *builtinCastIntAsDecimalSig) evalDecimal(row []types.Datum) (res *types.
 	if !mysql.HasUnsignedFlag(b.args[0].GetType().Flag) {
 		res = types.NewDecFromInt(val)
 	} else {
-		uVal, err := types.ConvertIntToUint(val, types.UnsignedUpperBound[mysql.TypeLonglong], mysql.TypeLonglong)
+		var uVal uint64
+		uVal, err = types.ConvertIntToUint(val, types.UnsignedUpperBound[mysql.TypeLonglong], mysql.TypeLonglong)
 		if err != nil {
 			return res, false, errors.Trace(err)
 		}
@@ -390,7 +391,8 @@ func (b *builtinCastIntAsStringSig) evalString(row []types.Datum) (res string, i
 	if !mysql.HasUnsignedFlag(b.args[0].GetType().Flag) {
 		res = strconv.FormatInt(val, 10)
 	} else {
-		uVal, err := types.ConvertIntToUint(val, types.UnsignedUpperBound[mysql.TypeLonglong], mysql.TypeLonglong)
+		var uVal uint64
+		uVal, err = types.ConvertIntToUint(val, types.UnsignedUpperBound[mysql.TypeLonglong], mysql.TypeLonglong)
 		if err != nil {
 			return res, false, errors.Trace(err)
 		}
diff --git a/expression/builtin_compare.go b/expression/builtin_compare.go
index 03aa9f3119354..8b8f2cfc4ae17 100644
--- a/expression/builtin_compare.go
+++ b/expression/builtin_compare.go
@@ -962,7 +962,8 @@ func (s *builtinCompareSig) eval(row []types.Datum) (d types.Datum, err error) {
 	}
 
 	if s.op != opcode.NullEQ {
-		if aa, bb, err := types.CoerceDatum(sc, a, b); err == nil {
+		var aa, bb types.Datum
+		if aa, bb, err = types.CoerceDatum(sc, a, b); err == nil {
 			a = aa
 			b = bb
 		}
diff --git a/expression/builtin_json_test.go b/expression/builtin_json_test.go
index 2d22548ddb89b..2362ca551896e 100644
--- a/expression/builtin_json_test.go
+++ b/expression/builtin_json_test.go
@@ -94,10 +94,12 @@ func (s *testEvaluatorSuite) TestJSONExtract(c *C) {
 			c.Assert(err, IsNil)
 			switch x := t.Expected.(type) {
 			case string:
-				j1, err := json.ParseFromString(x)
+				var j1 json.JSON
+				j1, err = json.ParseFromString(x)
 				c.Assert(err, IsNil)
 				j2 := d.GetMysqlJSON()
-				cmp, err := json.CompareJSON(j1, j2)
+				var cmp int
+				cmp, err = json.CompareJSON(j1, j2)
 				c.Assert(err, IsNil)
 				c.Assert(cmp, Equals, 0)
 			}
@@ -134,10 +136,12 @@ func (s *testEvaluatorSuite) TestJSONSetInsertReplace(c *C) {
 			c.Assert(err, IsNil)
 			switch x := t.Expected.(type) {
 			case string:
-				j1, err := json.ParseFromString(x)
+				var j1 json.JSON
+				j1, err = json.ParseFromString(x)
 				c.Assert(err, IsNil)
 				j2 := d.GetMysqlJSON()
-				cmp, err := json.CompareJSON(j1, j2)
+				var cmp int
+				cmp, err = json.CompareJSON(j1, j2)
 				c.Assert(err, IsNil)
 				c.Assert(cmp, Equals, 0)
 			}
@@ -228,10 +232,12 @@ func (s *testEvaluatorSuite) TestJSONObject(c *C) {
 			c.Assert(err, IsNil)
 			switch x := t.Expected.(type) {
 			case string:
-				j1, err := json.ParseFromString(x)
+				var j1 json.JSON
+				j1, err = json.ParseFromString(x)
 				c.Assert(err, IsNil)
 				j2 := d.GetMysqlJSON()
-				cmp, err := json.CompareJSON(j1, j2)
+				var cmp int
+				cmp, err = json.CompareJSON(j1, j2)
 				c.Assert(err, IsNil)
 				c.Assert(cmp, Equals, 0)
 			}
@@ -277,10 +283,12 @@ func (s *testEvaluatorSuite) TestJSONORemove(c *C) {
 			c.Assert(err, IsNil)
 			switch x := t.Expected.(type) {
 			case string:
-				j1, err := json.ParseFromString(x)
+				var j1 json.JSON
+				j1, err = json.ParseFromString(x)
 				c.Assert(err, IsNil)
 				j2 := d.GetMysqlJSON()
-				cmp, err := json.CompareJSON(j1, j2)
+				var cmp int
+				cmp, err = json.CompareJSON(j1, j2)
 				c.Assert(err, IsNil)
 				c.Assert(cmp, Equals, 0)
 			}
diff --git a/expression/builtin_string.go b/expression/builtin_string.go
index 41d46880ee7b5..6f75331ebc32f 100644
--- a/expression/builtin_string.go
+++ b/expression/builtin_string.go
@@ -1947,7 +1947,8 @@ func (b *builtinExportSetSig) eval(row []types.Datum) (d types.Datum, err error)
 	)
 	switch len(args) {
 	case 5:
-		arg, err := args[4].ToInt64(b.ctx.GetSessionVars().StmtCtx)
+		var arg int64
+		arg, err = args[4].ToInt64(b.ctx.GetSessionVars().StmtCtx)
 		if err != nil {
 			return d, errors.Trace(err)
 		}
diff --git a/expression/helper.go b/expression/helper.go
index 5003c2b3ff9b6..5cd635ca0ecf2 100644
--- a/expression/helper.go
+++ b/expression/helper.go
@@ -71,7 +71,7 @@ func getTimeValue(ctx context.Context, v interface{}, tp byte, fsp int) (d types
 		if upperX == CurrentTimestamp {
 			value.Time = types.FromGoTime(defaultTime)
 			if tp == mysql.TypeTimestamp {
-				err := value.ConvertTimeZone(time.Local, ctx.GetSessionVars().GetTimeZone())
+				err = value.ConvertTimeZone(time.Local, ctx.GetSessionVars().GetTimeZone())
 				if err != nil {
 					return d, errors.Trace(err)
 				}
diff --git a/infoschema/builder.go b/infoschema/builder.go
index acc75a64d0ff0..7bfee388d3446 100644
--- a/infoschema/builder.go
+++ b/infoschema/builder.go
@@ -153,10 +153,10 @@ func (b *Builder) applyCreateTable(m *meta.Meta, roDBInfo *model.DBInfo, tableID
 	tableNames := b.is.schemaMap[roDBInfo.Name.L]
 	tableNames.tables[tblInfo.Name.L] = tbl
 	bucketIdx := tableBucketIdx(tableID)
-	sortedTables := b.is.sortedTablesBuckets[bucketIdx]
-	sortedTables = append(sortedTables, tbl)
-	sort.Sort(sortedTables)
-	b.is.sortedTablesBuckets[bucketIdx] = sortedTables
+	sortedTbls := b.is.sortedTablesBuckets[bucketIdx]
+	sortedTbls = append(sortedTbls, tbl)
+	sort.Sort(sortedTbls)
+	b.is.sortedTablesBuckets[bucketIdx] = sortedTbls
 
 	newTbl, ok := b.is.TableByID(tableID)
 	if ok {
@@ -167,16 +167,16 @@ func (b *Builder) applyCreateTable(m *meta.Meta, roDBInfo *model.DBInfo, tableID
 
 func (b *Builder) applyDropTable(roDBInfo *model.DBInfo, tableID int64) {
 	bucketIdx := tableBucketIdx(tableID)
-	sortedTables := b.is.sortedTablesBuckets[bucketIdx]
-	idx := sortedTables.searchTable(tableID)
+	sortedTbls := b.is.sortedTablesBuckets[bucketIdx]
+	idx := sortedTbls.searchTable(tableID)
 	if idx == -1 {
 		return
 	}
 	if tableNames, ok := b.is.schemaMap[roDBInfo.Name.L]; ok {
-		delete(tableNames.tables, sortedTables[idx].Meta().Name.L)
+		delete(tableNames.tables, sortedTbls[idx].Meta().Name.L)
 	}
 	// Remove the table in sorted table slice.
-	b.is.sortedTablesBuckets[bucketIdx] = append(sortedTables[0:idx], sortedTables[idx+1:]...)
+	b.is.sortedTablesBuckets[bucketIdx] = append(sortedTbls[0:idx], sortedTbls[idx+1:]...)
 
 	// The old DBInfo still holds a reference to old table info, we need to remove it.
 	for i, tblInfo := range roDBInfo.Tables {
@@ -256,8 +256,8 @@ func (b *Builder) createSchemaTablesForDB(di *model.DBInfo) error {
 			return errors.Trace(err)
 		}
 		schTbls.tables[t.Name.L] = tbl
-		sortedTables := b.is.sortedTablesBuckets[tableBucketIdx(t.ID)]
-		b.is.sortedTablesBuckets[tableBucketIdx(t.ID)] = append(sortedTables, tbl)
+		sortedTbls := b.is.sortedTablesBuckets[tableBucketIdx(t.ID)]
+		b.is.sortedTablesBuckets[tableBucketIdx(t.ID)] = append(sortedTbls, tbl)
 	}
 	return nil
 }
diff --git a/kv/fault_injection_test.go b/kv/fault_injection_test.go
index babac20b3a8f9..2bae33a47eed7 100644
--- a/kv/fault_injection_test.go
+++ b/kv/fault_injection_test.go
@@ -33,7 +33,7 @@ func (s testFaultInjectionSuite) TestFaultInjectionBasic(c *C) {
 	c.Assert(err, IsNil)
 	_, err = storage.BeginWithStartTS(0)
 	c.Assert(err, IsNil)
-	ver := kv.Version{1}
+	ver := kv.Version{Ver: 1}
 	snap, err := storage.GetSnapshot(ver)
 	c.Assert(err, IsNil)
 	b, err := txn.Get([]byte{'a'})
diff --git a/perfschema/perfschema_test.go b/perfschema/perfschema_test.go
index 1a9ba0979fab1..9ef06de08d6cb 100644
--- a/perfschema/perfschema_test.go
+++ b/perfschema/perfschema_test.go
@@ -193,7 +193,8 @@ func mustQuery(c *C, se tidb.Session, s string) int {
 	_, err := r.Fields()
 	c.Assert(err, IsNil)
 	cnt := 0
-	for row, err := r.Next(); row != nil && err == nil; row, err = r.Next() {
+	var row *ast.Row
+	for row, err = r.Next(); row != nil && err == nil; row, err = r.Next() {
 		cnt++
 	}
 	c.Assert(err, IsNil)
diff --git a/plan/expression_rewriter.go b/plan/expression_rewriter.go
index 6baca080bc25f..ecd992bad770c 100644
--- a/plan/expression_rewriter.go
+++ b/plan/expression_rewriter.go
@@ -190,11 +190,12 @@ func (er *expressionRewriter) constructBinaryOpFunction(l expression.Expression,
 			expr1, _ = expression.NewFunction(er.ctx, ast.NE, types.NewFieldType(mysql.TypeTiny), larg0, rarg0)
 			expr2, _ = expression.NewFunction(er.ctx, op, types.NewFieldType(mysql.TypeTiny), larg0, rarg0)
 		}
-		l, err := popRowArg(er.ctx, l)
+		var err error
+		l, err = popRowArg(er.ctx, l)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
-		r, err := popRowArg(er.ctx, r)
+		r, err = popRowArg(er.ctx, r)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
diff --git a/plan/new_physical_plan_builder.go b/plan/new_physical_plan_builder.go
index 33cc175889934..466bbb2b7ff36 100644
--- a/plan/new_physical_plan_builder.go
+++ b/plan/new_physical_plan_builder.go
@@ -447,12 +447,12 @@ func (p *TopN) generatePhysicalPlans() []PhysicalPlan {
 // If this sort is a topN plan, we will try to push the sort down and leave the limit.
 // TODO: If this is a sort plan and the coming prop is not nil, this plan is redundant and can be removed.
 func (p *Sort) convert2NewPhysicalPlan(prop *requiredProp) (task, error) {
-	task, err := p.getTask(prop)
+	t, err := p.getTask(prop)
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	if task != nil {
-		return task, nil
+	if t != nil {
+		return t, nil
 	}
 	if prop.taskTp != rootTaskType {
 		// TODO: This is a trick here, because an operator that can be pushed to Coprocessor can never be pushed across sort.
@@ -462,11 +462,11 @@ func (p *Sort) convert2NewPhysicalPlan(prop *requiredProp) (task, error) {
 		return invalidTask, p.storeTask(prop, invalidTask)
 	}
 	// enforce branch
-	task, err = p.children[0].(LogicalPlan).convert2NewPhysicalPlan(&requiredProp{taskTp: rootTaskType, expectedCnt: math.MaxFloat64})
+	t, err = p.children[0].(LogicalPlan).convert2NewPhysicalPlan(&requiredProp{taskTp: rootTaskType, expectedCnt: math.MaxFloat64})
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	task = p.attach2Task(task)
+	t = p.attach2Task(t)
 	newProp, canPassProp := getPropByOrderByItems(p.ByItems)
 	if canPassProp {
 		newProp.expectedCnt = prop.expectedCnt
@@ -474,52 +474,52 @@ func (p *Sort) convert2NewPhysicalPlan(prop *requiredProp) (task, error) {
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
-		if orderedTask.cost() < task.cost() {
-			task = orderedTask
+		if orderedTask.cost() < t.cost() {
+			t = orderedTask
 		}
 	}
-	task = prop.enforceProperty(task, p.ctx, p.allocator)
-	return task, p.storeTask(prop, task)
+	t = prop.enforceProperty(t, p.ctx, p.allocator)
+	return t, p.storeTask(prop, t)
 }
 
 // convert2NewPhysicalPlan implements LogicalPlan interface.
 func (p *baseLogicalPlan) convert2NewPhysicalPlan(prop *requiredProp) (task, error) {
 	// look up the task map
-	task, err := p.getTask(prop)
+	t, err := p.getTask(prop)
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	if task != nil {
-		return task, nil
+	if t != nil {
+		return t, nil
 	}
-	task = invalidTask
+	t = invalidTask
 	if prop.taskTp != rootTaskType {
 		// Currently all plan cannot totally push down.
-		return task, p.storeTask(prop, task)
+		return t, p.storeTask(prop, t)
 	}
 	// Now we only consider rootTask.
 	if len(p.basePlan.children) == 0 {
 		// When the children length is 0, we process it specially.
-		task = &rootTask{p: p.basePlan.self.(PhysicalPlan)}
-		task = prop.enforceProperty(task, p.basePlan.ctx, p.basePlan.allocator)
-		return task, p.storeTask(prop, task)
+		t = &rootTask{p: p.basePlan.self.(PhysicalPlan)}
+		t = prop.enforceProperty(t, p.basePlan.ctx, p.basePlan.allocator)
+		return t, p.storeTask(prop, t)
 	}
 	// Else we suppose it only has one child.
 	for _, pp := range p.basePlan.self.(LogicalPlan).generatePhysicalPlans() {
 		// We consider to add enforcer firstly.
-		task, err = p.getBestTask(task, prop, pp, true)
+		t, err = p.getBestTask(t, prop, pp, true)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
 		if prop.isEmpty() {
 			continue
 		}
-		task, err = p.getBestTask(task, prop, pp, false)
+		t, err = p.getBestTask(t, prop, pp, false)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
 	}
-	return task, p.storeTask(prop, task)
+	return t, p.storeTask(prop, t)
 }
 
 func (p *baseLogicalPlan) getBestTask(bestTask task, prop *requiredProp, pp PhysicalPlan, enforced bool) (task, error) {
@@ -553,13 +553,13 @@ func tryToAddUnionScan(cop *copTask, conds []expression.Expression, ctx context.
 	if ctx.Txn() == nil || ctx.Txn().IsReadOnly() {
 		return cop
 	}
-	task := finishCopTask(cop, ctx, allocator)
+	t := finishCopTask(cop, ctx, allocator)
 	us := PhysicalUnionScan{
 		Conditions: conds,
 	}.init(allocator, ctx)
-	us.SetSchema(task.plan().Schema())
-	us.profile = task.plan().statsProfile()
-	return us.attach2Task(task)
+	us.SetSchema(t.plan().Schema())
+	us.profile = t.plan().statsProfile()
+	return us.attach2Task(t)
 }
 
 // tryToGetMemTask will check if this table is a mem table. If it is, it will produce a task and store it.
@@ -618,32 +618,32 @@ func (p *DataSource) tryToGetDualTask() (task, error) {
 // convert2NewPhysicalPlan implements the PhysicalPlan interface.
 // It will enumerate all the available indices and choose a plan with least cost.
 func (p *DataSource) convert2NewPhysicalPlan(prop *requiredProp) (task, error) {
-	task, err := p.getTask(prop)
+	t, err := p.getTask(prop)
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	if task != nil {
-		return task, nil
+	if t != nil {
+		return t, nil
 	}
-	task, err = p.tryToGetDualTask()
+	t, err = p.tryToGetDualTask()
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	if task != nil {
-		return task, p.storeTask(prop, task)
+	if t != nil {
+		return t, p.storeTask(prop, t)
 	}
-	task, err = p.tryToGetMemTask(prop)
+	t, err = p.tryToGetMemTask(prop)
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	if task != nil {
-		return task, p.storeTask(prop, task)
+	if t != nil {
+		return t, p.storeTask(prop, t)
 	}
 	// TODO: We have not checked if this table has a predicate. If not, we can only consider table scan.
 	indices, includeTableScan := availableIndices(p.indexHints, p.tableInfo)
-	task = invalidTask
+	t = invalidTask
 	if includeTableScan {
-		task, err = p.convertToTableScan(prop)
+		t, err = p.convertToTableScan(prop)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
@@ -653,11 +653,11 @@ func (p *DataSource) convert2NewPhysicalPlan(prop *requiredProp) (task, error) {
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
-		if idxTask.cost() < task.cost() {
-			task = idxTask
+		if idxTask.cost() < t.cost() {
+			t = idxTask
 		}
 	}
-	return task, p.storeTask(prop, task)
+	return t, p.storeTask(prop, t)
 }
 
 // convertToIndexScan converts the DataSource to index scan with idx.
diff --git a/plan/optimizer.go b/plan/optimizer.go
index 89a42ed8a77cb..06fa5fda22379 100644
--- a/plan/optimizer.go
+++ b/plan/optimizer.go
@@ -156,11 +156,11 @@ func logicalOptimize(flag uint64, logic LogicalPlan, ctx context.Context, alloc
 func dagPhysicalOptimize(logic LogicalPlan) (PhysicalPlan, error) {
 	logic.preparePossibleProperties()
 	logic.prepareStatsProfile()
-	task, err := logic.convert2NewPhysicalPlan(&requiredProp{taskTp: rootTaskType, expectedCnt: math.MaxFloat64})
+	t, err := logic.convert2NewPhysicalPlan(&requiredProp{taskTp: rootTaskType, expectedCnt: math.MaxFloat64})
 	if err != nil {
 		return nil, errors.Trace(err)
 	}
-	p := task.plan()
+	p := t.plan()
 	p.ResolveIndices()
 	return p, nil
 }
diff --git a/plan/physical_plan_builder.go b/plan/physical_plan_builder.go
index 70ab8638a6c78..adf5f198d0bcc 100644
--- a/plan/physical_plan_builder.go
+++ b/plan/physical_plan_builder.go
@@ -65,7 +65,7 @@ func (p *DataSource) convert2TableScan(prop *requiredProperty) (*physicalPlanInf
 	resultPlan = ts
 	table := p.tableInfo
 	sc := p.ctx.GetSessionVars().StmtCtx
-	ts.Ranges = []types.IntColumnRange{{math.MinInt64, math.MaxInt64}}
+	ts.Ranges = []types.IntColumnRange{{LowVal: math.MinInt64, HighVal: math.MaxInt64}}
 	if len(p.parents) > 0 {
 		if sel, ok := p.parents[0].(*Selection); ok {
 			newSel := sel.Copy().(*Selection)
@@ -976,7 +976,8 @@ func (p *LogicalJoin) convert2PhysicalPlan(prop *requiredProperty) (*physicalPla
 			}
 		}
 
-		nljInfo, err := p.convert2IndexNestedLoopJoinLeft(prop, false)
+		var nljInfo *physicalPlanInfo
+		nljInfo, err = p.convert2IndexNestedLoopJoinLeft(prop, false)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
@@ -999,7 +1000,8 @@ func (p *LogicalJoin) convert2PhysicalPlan(prop *requiredProperty) (*physicalPla
 				break
 			}
 		}
-		nljInfo, err := p.convert2IndexNestedLoopJoinRight(prop, false)
+		var nljInfo *physicalPlanInfo
+		nljInfo, err = p.convert2IndexNestedLoopJoinRight(prop, false)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
diff --git a/plan/task.go b/plan/task.go
index 1e90230908c87..c4906482fa3cc 100644
--- a/plan/task.go
+++ b/plan/task.go
@@ -110,8 +110,8 @@ func (t *copTask) finishIndexPlan() {
 }
 
 func (p *basePhysicalPlan) attach2Task(tasks ...task) task {
-	task := finishCopTask(tasks[0].copy(), p.basePlan.ctx, p.basePlan.allocator)
-	return attachPlan2Task(p.basePlan.self.(PhysicalPlan).Copy(), task)
+	t := finishCopTask(tasks[0].copy(), p.basePlan.ctx, p.basePlan.allocator)
+	return attachPlan2Task(p.basePlan.self.(PhysicalPlan).Copy(), t)
 }
 
 func (p *PhysicalApply) attach2Task(tasks ...task) task {
@@ -270,8 +270,8 @@ func (p *Limit) attach2Task(tasks ...task) task {
 	if tasks[0].plan() == nil {
 		return tasks[0]
 	}
-	task := tasks[0].copy()
-	if cop, ok := task.(*copTask); ok {
+	t := tasks[0].copy()
+	if cop, ok := t.(*copTask); ok {
 		// If the task is copTask, the Limit can always be pushed down.
 		// When limit be pushed down, it should remove its offset.
 		pushedDownLimit := Limit{Count: p.Offset + p.Count}.init(p.allocator, p.ctx)
@@ -282,12 +282,12 @@ func (p *Limit) attach2Task(tasks ...task) task {
 			pushedDownLimit.SetSchema(cop.indexPlan.Schema())
 		}
 		cop = attachPlan2Task(pushedDownLimit, cop).(*copTask)
-		task = finishCopTask(cop, p.ctx, p.allocator)
+		t = finishCopTask(cop, p.ctx, p.allocator)
 	}
 	if !p.partial {
-		task = attachPlan2Task(p.Copy(), task)
+		t = attachPlan2Task(p.Copy(), t)
 	}
-	return task
+	return t
 }
 
 func (p *Sort) getCost(count float64) float64 {
@@ -317,11 +317,11 @@ func (p *TopN) allColsFromSchema(schema *expression.Schema) bool {
 }
 
 func (p *Sort) attach2Task(tasks ...task) task {
-	task := tasks[0].copy()
-	task = finishCopTask(task, p.ctx, p.allocator)
-	task = attachPlan2Task(p.Copy(), task)
-	task.addCost(p.getCost(task.count()))
-	return task
+	t := tasks[0].copy()
+	t = finishCopTask(t, p.ctx, p.allocator)
+	t = attachPlan2Task(p.Copy(), t)
+	t.addCost(p.getCost(t.count()))
+	return t
 }
 
 func (p *TopN) attach2Task(tasks ...task) task {
@@ -329,9 +329,9 @@ func (p *TopN) attach2Task(tasks ...task) task {
 	if tasks[0].plan() == nil {
 		return tasks[0]
 	}
-	task := tasks[0].copy()
+	t := tasks[0].copy()
 	// This is a topN plan.
-	if copTask, ok := task.(*copTask); ok && p.canPushDown() {
+	if copTask, ok := t.(*copTask); ok && p.canPushDown() {
 		pushedDownTopN := p.Copy().(*TopN)
 		// When topN is pushed down, it should remove its offset.
 		pushedDownTopN.Count, pushedDownTopN.Offset = p.Count+p.Offset, 0
@@ -349,27 +349,27 @@ func (p *TopN) attach2Task(tasks ...task) task {
 			copTask.tablePlan = pushedDownTopN
 			pushedDownTopN.SetSchema(copTask.tablePlan.Schema())
 		}
-		copTask.addCost(pushedDownTopN.getCost(task.count()))
+		copTask.addCost(pushedDownTopN.getCost(t.count()))
 	}
-	task = finishCopTask(task, p.ctx, p.allocator)
+	t = finishCopTask(t, p.ctx, p.allocator)
 	if !p.partial {
-		task = attachPlan2Task(p.Copy(), task)
-		task.addCost(p.getCost(task.count()))
+		t = attachPlan2Task(p.Copy(), t)
+		t.addCost(p.getCost(t.count()))
 	}
-	return task
+	return t
 }
 
 func (p *Projection) attach2Task(tasks ...task) task {
-	task := tasks[0].copy()
+	t := tasks[0].copy()
 	np := p.Copy()
-	switch t := task.(type) {
+	switch tp := t.(type) {
 	case *copTask:
 		// TODO: Support projection push down.
-		task := finishCopTask(task, p.ctx, p.allocator)
-		task = attachPlan2Task(np, task)
-		return task
+		t = finishCopTask(t, p.ctx, p.allocator)
+		t = attachPlan2Task(np, t)
+		return t
 	case *rootTask:
-		return attachPlan2Task(np, t)
+		return attachPlan2Task(np, tp)
 	}
 	return nil
 }
@@ -388,10 +388,10 @@ func (p *Union) attach2Task(tasks ...task) task {
 }
 
 func (sel *Selection) attach2Task(tasks ...task) task {
-	task := finishCopTask(tasks[0].copy(), sel.ctx, sel.allocator)
-	task.addCost(task.count() * cpuFactor)
-	task = attachPlan2Task(sel.Copy(), task)
-	return task
+	t := finishCopTask(tasks[0].copy(), sel.ctx, sel.allocator)
+	t.addCost(t.count() * cpuFactor)
+	t = attachPlan2Task(sel.Copy(), t)
+	return t
 }
 
 func (p *PhysicalAggregation) newPartialAggregate() (partialAgg, finalAgg *PhysicalAggregation) {
diff --git a/server/region_handler_test.go b/server/region_handler_test.go
index 582b57a9da88c..724525ae56e96 100644
--- a/server/region_handler_test.go
+++ b/server/region_handler_test.go
@@ -45,9 +45,9 @@ func (ts *TidbRegionHandlerTestSuite) TestRegionIndexRange(c *C) {
 	startKey := codec.EncodeBytes(nil, tablecodec.EncodeTableIndexPrefix(sTableID, sIndex))
 	endKey := codec.EncodeBytes(nil, tablecodec.GenTableRecordPrefix(eTableID))
 	region := &tikv.KeyLocation{
-		tikv.RegionVerID{},
-		startKey,
-		endKey,
+		Region:   tikv.RegionVerID{},
+		StartKey: startKey,
+		EndKey:   endKey,
 	}
 	indexRange, err := NewRegionFrameRange(region)
 	c.Assert(err, IsNil)
@@ -70,9 +70,9 @@ func (ts *TidbRegionHandlerTestSuite) TestRegionIndexRangeWithEndNoLimit(c *C) {
 	startKey := codec.EncodeBytes(nil, tablecodec.GenTableRecordPrefix(sTableID))
 	endKey := codec.EncodeBytes(nil, []byte("z_aaaaafdfd"))
 	region := &tikv.KeyLocation{
-		tikv.RegionVerID{},
-		startKey,
-		endKey,
+		Region:   tikv.RegionVerID{},
+		StartKey: startKey,
+		EndKey:   endKey,
 	}
 	indexRange, err := NewRegionFrameRange(region)
 	c.Assert(err, IsNil)
@@ -95,9 +95,9 @@ func (ts *TidbRegionHandlerTestSuite) TestRegionIndexRangeWithStartNoLimit(c *C)
 	startKey := codec.EncodeBytes(nil, []byte("m_aaaaafdfd"))
 	endKey := codec.EncodeBytes(nil, tablecodec.GenTableRecordPrefix(eTableID))
 	region := &tikv.KeyLocation{
-		tikv.RegionVerID{},
-		startKey,
-		endKey,
+		Region:   tikv.RegionVerID{},
+		StartKey: startKey,
+		EndKey:   endKey,
 	}
 	indexRange, err := NewRegionFrameRange(region)
 	c.Assert(err, IsNil)
diff --git a/sessionctx/varsutil/varsutil_test.go b/sessionctx/varsutil/varsutil_test.go
index 59d8eac1b95c8..c873e9f3360e4 100644
--- a/sessionctx/varsutil/varsutil_test.go
+++ b/sessionctx/varsutil/varsutil_test.go
@@ -118,7 +118,7 @@ func (s *testVarsutilSuite) TestVarsutil(c *C) {
 		{"-6:00", "UTC", true, 6 * time.Hour},
 	}
 	for _, tt := range tests {
-		err := SetSessionSystemVar(v, variable.TimeZone, types.NewStringDatum(tt.input))
+		err = SetSessionSystemVar(v, variable.TimeZone, types.NewStringDatum(tt.input))
 		c.Assert(err, IsNil)
 		c.Assert(v.TimeZone.String(), Equals, tt.expect)
 		if tt.compareValue {
diff --git a/statistics/ddl.go b/statistics/ddl.go
index 16686b1c6c0db..856d1c2185af2 100644
--- a/statistics/ddl.go
+++ b/statistics/ddl.go
@@ -18,6 +18,7 @@ import (
 
 	"github.com/juju/errors"
 	"github.com/ngaut/log"
+	"github.com/pingcap/tidb/ast"
 	"github.com/pingcap/tidb/ddl"
 	"github.com/pingcap/tidb/model"
 	"github.com/pingcap/tidb/mysql"
@@ -118,11 +119,13 @@ func (h *Handle) insertColStats2KV(tableID int64, colInfo *model.ColumnInfo) err
 	if h.ctx.GetSessionVars().StmtCtx.AffectedRows() > 0 {
 		exec := h.ctx.(sqlexec.SQLExecutor)
 		// By this step we can get the count of this table, then we can sure the count and repeats of bucket.
-		rs, err := exec.Execute(fmt.Sprintf("select count from mysql.stats_meta where table_id = %d", tableID))
+		var rs []ast.RecordSet
+		rs, err = exec.Execute(fmt.Sprintf("select count from mysql.stats_meta where table_id = %d", tableID))
 		if err != nil {
 			return errors.Trace(err)
 		}
-		row, err := rs[0].Next()
+		var row *ast.Row
+		row, err = rs[0].Next()
 		if err != nil {
 			return errors.Trace(err)
 		}
diff --git a/statistics/histogram.go b/statistics/histogram.go
index 7020c4d59c6d1..9b47122ab8816 100644
--- a/statistics/histogram.go
+++ b/statistics/histogram.go
@@ -87,11 +87,13 @@ func (hg *Histogram) SaveToStorage(ctx context.Context, tableID int64, count int
 		} else {
 			count = bucket.Count - hg.Buckets[i-1].Count
 		}
-		upperBound, err := bucket.UpperBound.ConvertTo(ctx.GetSessionVars().StmtCtx, types.NewFieldType(mysql.TypeBlob))
+		var upperBound types.Datum
+		upperBound, err = bucket.UpperBound.ConvertTo(ctx.GetSessionVars().StmtCtx, types.NewFieldType(mysql.TypeBlob))
 		if err != nil {
 			return errors.Trace(err)
 		}
-		lowerBound, err := bucket.LowerBound.ConvertTo(ctx.GetSessionVars().StmtCtx, types.NewFieldType(mysql.TypeBlob))
+		var lowerBound types.Datum
+		lowerBound, err = bucket.LowerBound.ConvertTo(ctx.GetSessionVars().StmtCtx, types.NewFieldType(mysql.TypeBlob))
 		if err != nil {
 			return errors.Trace(err)
 		}
@@ -389,7 +391,8 @@ func (c *Column) getColumnRowCount(sc *variable.StatementContext, ranges []*type
 		if cmp == 0 {
 			// the point case.
 			if !rg.LowExcl && !rg.HighExcl {
-				cnt, err := c.equalRowCount(sc, rg.Low)
+				var cnt float64
+				cnt, err = c.equalRowCount(sc, rg.Low)
 				if err != nil {
 					return 0, errors.Trace(err)
 				}
diff --git a/store/tikv/2pc.go b/store/tikv/2pc.go
index f404ab81e685c..865cc8071e9c0 100644
--- a/store/tikv/2pc.go
+++ b/store/tikv/2pc.go
@@ -580,7 +580,7 @@ func (c *twoPhaseCommitter) execute() error {
 		return errors.Trace(err)
 	}
 	c.commitTS = commitTS
-	if err := c.checkSchemaValid(); err != nil {
+	if err = c.checkSchemaValid(); err != nil {
 		return errors.Trace(err)
 	}
 
diff --git a/store/tikv/mock-tikv/cop_handler_dag.go b/store/tikv/mock-tikv/cop_handler_dag.go
index a014ea9dd6b7b..1044846534755 100644
--- a/store/tikv/mock-tikv/cop_handler_dag.go
+++ b/store/tikv/mock-tikv/cop_handler_dag.go
@@ -65,7 +65,11 @@ func (h *rpcHandler) handleCopDAGRequest(req *coprocessor.Request) (*coprocessor
 	}
 	var chunks []tipb.Chunk
 	for {
-		handle, row, err := e.Next()
+		var (
+			handle int64
+			row    [][]byte
+		)
+		handle, row, err = e.Next()
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
@@ -185,7 +189,8 @@ func (h *rpcHandler) buildAggregation(ctx *dagContext, executor *tipb.Executor)
 	var err error
 	var relatedColOffsets []int
 	for _, expr := range executor.Aggregation.AggFunc {
-		aggExpr, err := expression.NewDistAggFunc(expr, ctx.evalCtx.fieldTps, ctx.evalCtx.sc)
+		var aggExpr expression.AggregationFunction
+		aggExpr, err = expression.NewDistAggFunc(expr, ctx.evalCtx.fieldTps, ctx.evalCtx.sc)
 		if err != nil {
 			return nil, errors.Trace(err)
 		}
diff --git a/table/tables/tables.go b/table/tables/tables.go
index cc3be4c473d28..e66f9881cf63f 100644
--- a/table/tables/tables.go
+++ b/table/tables/tables.go
@@ -239,9 +239,9 @@ func (t *Table) UpdateRecord(ctx context.Context, h int64, oldData, newData []ty
 			if err != nil {
 				return errors.Trace(err)
 			}
-			cmp, err := oldData[col.Offset].CompareDatum(ctx.GetSessionVars().StmtCtx, value)
-			if err != nil {
-				return errors.Trace(err)
+			cmp, errCmp := oldData[col.Offset].CompareDatum(ctx.GetSessionVars().StmtCtx, value)
+			if errCmp != nil {
+				return errors.Trace(errCmp)
 			}
 			if cmp != 0 {
 				value = oldData[col.Offset]
diff --git a/util/filesort/filesort.go b/util/filesort/filesort.go
index e31684f323a30..2875ce084e303 100644
--- a/util/filesort/filesort.go
+++ b/util/filesort/filesort.go
@@ -384,12 +384,12 @@ func (fs *FileSorter) externalSort() (*comparableRow, error) {
 			return nil, errors.Trace(err)
 		}
 		if row != nil {
-			im := &item{
+			nextIm := &item{
 				index: im.index,
 				value: row,
 			}
 
-			heap.Push(fs.rowHeap, im)
+			heap.Push(fs.rowHeap, nextIm)
 			if fs.rowHeap.err != nil {
 				return nil, errors.Trace(fs.rowHeap.err)
 			}
diff --git a/util/types/datum.go b/util/types/datum.go
index b1ec6e2c615fb..96b6ec4fe2f88 100644
--- a/util/types/datum.go
+++ b/util/types/datum.go
@@ -1609,7 +1609,8 @@ func CoerceDatum(sc *variable.StatementContext, a, b Datum) (x, y Datum, err err
 		case KindMysqlSet:
 			x.SetFloat64(x.GetMysqlSet().ToNumber())
 		case KindMysqlDecimal:
-			fval, err := x.ToFloat64(sc)
+			var fval float64
+			fval, err = x.ToFloat64(sc)
 			if err != nil {
 				return x, y, errors.Trace(err)
 			}
@@ -1629,7 +1630,8 @@ func CoerceDatum(sc *variable.StatementContext, a, b Datum) (x, y Datum, err err
 		case KindMysqlSet:
 			y.SetFloat64(y.GetMysqlSet().ToNumber())
 		case KindMysqlDecimal:
-			fval, err := y.ToFloat64(sc)
+			var fval float64
+			fval, err = y.ToFloat64(sc)
 			if err != nil {
 				return x, y, errors.Trace(err)
 			}
diff --git a/util/types/datum_eval.go b/util/types/datum_eval.go
index 3a77890f43650..e5fffa13f461b 100644
--- a/util/types/datum_eval.go
+++ b/util/types/datum_eval.go
@@ -405,7 +405,8 @@ func decimal2RoundUint(x *MyDecimal) (uint64, error) {
 		err   error
 	)
 	if roundX.IsNegative() {
-		intX, err := roundX.ToInt()
+		var intX int64
+		intX, err = roundX.ToInt()
 		if err != nil && err != ErrTruncated {
 			return 0, errors.Trace(err)
 		}
diff --git a/util/types/datum_test.go b/util/types/datum_test.go
index 88cf8b3fd5d79..79ab6d68d263d 100644
--- a/util/types/datum_test.go
+++ b/util/types/datum_test.go
@@ -221,10 +221,12 @@ func (ts *testDatumSuite) TestToJSON(c *C) {
 			c.Assert(err, IsNil)
 
 			sd := NewStringDatum(tt.expected)
-			expected, err := sd.ConvertTo(sc, ft)
+			var expected Datum
+			expected, err = sd.ConvertTo(sc, ft)
 			c.Assert(err, IsNil)
 
-			cmp, err := obtain.CompareDatum(sc, expected)
+			var cmp int
+			cmp, err = obtain.CompareDatum(sc, expected)
 			c.Assert(err, IsNil)
 			c.Assert(cmp, Equals, 0)
 		} else {
diff --git a/util/types/json/functions_test.go b/util/types/json/functions_test.go
index 520c395885c1d..545cd7b842913 100644
--- a/util/types/json/functions_test.go
+++ b/util/types/json/functions_test.go
@@ -215,7 +215,8 @@ func (s *testJSONSuite) TestJSONModify(c *C) {
 		obtain, err := base.Modify([]PathExpression{pathExpr}, []JSON{value}, tt.mt)
 		if tt.success {
 			c.Assert(err, IsNil)
-			cmp, err := CompareJSON(obtain, expected)
+			var cmp int
+			cmp, err = CompareJSON(obtain, expected)
 			c.Assert(err, IsNil)
 			c.Assert(cmp, Equals, 0)
 		} else {
diff --git a/util/types/json/normalize.go b/util/types/json/normalize.go
index c39794e4806e0..8e90cad60cb68 100644
--- a/util/types/json/normalize.go
+++ b/util/types/json/normalize.go
@@ -44,7 +44,7 @@ func normalize(in interface{}) (j JSON, err error) {
 		j.typeCode = typeCodeFloat64
 		*(*float64)(unsafe.Pointer(&j.i64)) = t
 	case json.Number:
-		if i64, err := t.Int64(); err == nil {
+		if i64, errTp := t.Int64(); errTp == nil {
 			j.typeCode = typeCodeInt64
 			j.i64 = i64
 		} else {
@@ -75,7 +75,8 @@ func normalize(in interface{}) (j JSON, err error) {
 		j.typeCode = typeCodeArray
 		j.array = make([]JSON, 0, len(t))
 		for _, elem := range t {
-			elem1, err := normalize(elem)
+			var elem1 JSON
+			elem1, err = normalize(elem)
 			if err != nil {
 				return j, err
 			}