*: gofmt code for adapting go 1.19

br/pkg/glue/console_glue.go

@@ -129,8 +129,10 @@ func (t *Table) maxKeyLen() int {
 
 // Print prints the table.
 // The format would be like:
-//    Key1: <Value>
-//   Other: <Value>
+//
+//	 Key1: <Value>
+//	Other: <Value>
+//
 // LongKey: <Value>
 // The format may change if the terminal size is small.
 func (t *Table) Print() {
@@ -305,7 +307,9 @@ func (ps PrettyString) slicePointOf(s int) (realSlicePoint, endAt int) {
 // It is the abstraction of some subarea of the terminal,
 // you might imagine it as a panel in the tmux, but with infinity height.
 // For example, printing a frame with the width of 10 chars, and 4 chars offset left, would be like:
-//    v~~~~~~~~~~v Here is the "width of a frame".
+//
+//	v~~~~~~~~~~v Here is the "width of a frame".
+//
 // +--+----------+--+
 // |   Hello, wor   |
 // |   ld.          |

br/pkg/lightning/backend/local/duplicate.go

@@ -246,6 +246,7 @@ type DupKVStream interface {
 
 // LocalDupKVStream implements the interface of DupKVStream.
 // It collects duplicate key-value pairs from a pebble.DB.
+//
 //goland:noinspection GoNameStartsWithPackageName
 type LocalDupKVStream struct {
 	iter Iter

br/pkg/lightning/backend/noop/noop.go

@@ -97,14 +97,14 @@ func (b noopBackend) CheckRequirements(context.Context, *backend.CheckCtx) error
 // name. The returned table info does not need to be precise if the encoder,
 // is not requiring them, but must at least fill in the following fields for
 // TablesFromMeta to succeed:
-//  - Name
-//  - State (must be model.StatePublic)
-//  - ID
-//  - Columns
-//     * Name
-//     * State (must be model.StatePublic)
-//     * Offset (must be 0, 1, 2, ...)
-//  - PKIsHandle (true = do not generate _tidb_rowid)
+//   - Name
+//   - State (must be model.StatePublic)
+//   - ID
+//   - Columns
+//   - Name
+//   - State (must be model.StatePublic)
+//   - Offset (must be 0, 1, 2, ...)
+//   - PKIsHandle (true = do not generate _tidb_rowid)
 func (b noopBackend) FetchRemoteTableModels(ctx context.Context, schemaName string) ([]*model.TableInfo, error) {
 	return nil, nil
 }

br/pkg/lightning/backend/tidb/tidb.go

@@ -627,7 +627,8 @@ type stmtTask struct {
 }
 
 // WriteBatchRowsToDB write rows in batch mode, which will insert multiple rows like this:
-//   insert into t1 values (111), (222), (333), (444);
+//
+//	insert into t1 values (111), (222), (333), (444);
 func (be *tidbBackend) WriteBatchRowsToDB(ctx context.Context, tableName string, columnNames []string, r kv.Rows) error {
 	rows := r.(tidbRows)
 	insertStmt := be.checkAndBuildStmt(rows, tableName, columnNames)
@@ -655,10 +656,12 @@ func (be *tidbBackend) checkAndBuildStmt(rows tidbRows, tableName string, column
 }
 
 // WriteRowsToDB write rows in row-by-row mode, which will insert multiple rows like this:
-//   insert into t1 values (111);
-//   insert into t1 values (222);
-//   insert into t1 values (333);
-//   insert into t1 values (444);
+//
+//	insert into t1 values (111);
+//	insert into t1 values (222);
+//	insert into t1 values (333);
+//	insert into t1 values (444);
+//
 // See more details in br#1366: https://github.com/pingcap/br/issues/1366
 func (be *tidbBackend) WriteRowsToDB(ctx context.Context, tableName string, columnNames []string, r kv.Rows) error {
 	rows := r.(tidbRows)

br/pkg/lightning/backend/tidb/tidb_test.go

@@ -214,6 +214,7 @@ func TestWriteRowsErrorOnDup(t *testing.T) {
 }
 
 // TODO: temporarily disable this test before we fix strict mode
+//
 //nolint:unused,deadcode
 func testStrictMode(t *testing.T) {
 	s := createMysqlSuite(t)

br/pkg/lightning/lightning.go

@@ -257,11 +257,12 @@ func (l *Lightning) goServe(statusAddr string, realAddrWriter io.Writer) error {
 }
 
 // RunOnce is used by binary lightning and host when using lightning as a library.
-// - for binary lightning, taskCtx could be context.Background which means taskCtx wouldn't be canceled directly by its
-//   cancel function, but only by Lightning.Stop or HTTP DELETE using l.cancel. and glue could be nil to let lightning
-//   use a default glue later.
-// - for lightning as a library, taskCtx could be a meaningful context that get canceled outside, and glue could be a
-//   caller implemented glue.
+//   - for binary lightning, taskCtx could be context.Background which means taskCtx wouldn't be canceled directly by its
+//     cancel function, but only by Lightning.Stop or HTTP DELETE using l.cancel. and glue could be nil to let lightning
+//     use a default glue later.
+//   - for lightning as a library, taskCtx could be a meaningful context that get canceled outside, and glue could be a
+//     caller implemented glue.
+//
 // deprecated: use RunOnceWithOptions instead.
 func (l *Lightning) RunOnce(taskCtx context.Context, taskCfg *config.Config, glue glue.Glue) error {
 	if err := taskCfg.Adjust(taskCtx); err != nil {
@@ -309,10 +310,10 @@ func (l *Lightning) RunServer() error {
 }
 
 // RunOnceWithOptions is used by binary lightning and host when using lightning as a library.
-// - for binary lightning, taskCtx could be context.Background which means taskCtx wouldn't be canceled directly by its
-//   cancel function, but only by Lightning.Stop or HTTP DELETE using l.cancel. No need to set Options
-// - for lightning as a library, taskCtx could be a meaningful context that get canceled outside, and there Options may
-//   be used:
+//   - for binary lightning, taskCtx could be context.Background which means taskCtx wouldn't be canceled directly by its
+//     cancel function, but only by Lightning.Stop or HTTP DELETE using l.cancel. No need to set Options
+//   - for lightning as a library, taskCtx could be a meaningful context that get canceled outside, and there Options may
+//     be used:
 //   - WithGlue: set a caller implemented glue. Otherwise, lightning will use a default glue later.
 //   - WithDumpFileStorage: caller has opened an external storage for lightning. Otherwise, lightning will open a
 //     storage by config

br/pkg/lightning/mydump/loader.go

@@ -100,7 +100,7 @@ func (m *MDTableMeta) GetSchema(ctx context.Context, store storage.ExternalStora
 }
 
 /*
-	Mydumper File Loader
+Mydumper File Loader
 */
 type MDLoader struct {
 	store  storage.ExternalStorage

br/pkg/lightning/mydump/region_test.go

@@ -36,7 +36,7 @@ import (
 // }
 
 /*
-	TODO : test with specified 'regionBlockSize' ...
+TODO : test with specified 'regionBlockSize' ...
 */
 func TestTableRegion(t *testing.T) {
 	cfg := newConfigWithSourceDir("./examples")

br/pkg/lightning/restore/precheck_impl.go

@@ -866,10 +866,10 @@ func (ci *csvHeaderCheckItem) GetCheckItemID() CheckItemID {
 }
 
 // Check tries to check whether the csv header config is consistent with the source csv files by:
-// 1. pick one table with two CSV files and a unique/primary key
-// 2. read the first row of those two CSV files
-// 3. checks if the content of those first rows are compatible with the table schema, and whether the
-//    two rows are identical, to determine if the first rows are a header rows.
+//  1. pick one table with two CSV files and a unique/primary key
+//  2. read the first row of those two CSV files
+//  3. checks if the content of those first rows are compatible with the table schema, and whether the
+//     two rows are identical, to determine if the first rows are a header rows.
 func (ci *csvHeaderCheckItem) Check(ctx context.Context) (*CheckResult, error) {
 	// if cfg set header = true but source files actually contain not header, former SchemaCheck should
 	// return error in this situation, so we need do it again.

br/pkg/restore/db.go

@@ -171,7 +171,6 @@ func (db *DB) CreateDatabase(ctx context.Context, schema *model.DBInfo) error {
 	return errors.Trace(err)
 }
 
-//
 func (db *DB) restoreSequence(ctx context.Context, table *metautil.Table) error {
 	var restoreMetaSQL string
 	var err error

br/pkg/restore/split_test.go

@@ -320,8 +320,9 @@ func TestScatterFinishInTime(t *testing.T) {
 // range: [aaa, aae), [aae, aaz), [ccd, ccf), [ccf, ccj)
 // rewrite rules: aa -> xx,  cc -> bb
 // expected regions after split:
-//   [, aay), [aay, bba), [bba, bbf), [bbf, bbh), [bbh, bbj),
-//   [bbj, cca), [cca, xxe), [xxe, xxz), [xxz, )
+//
+//	[, aay), [aay, bba), [bba, bbf), [bbf, bbh), [bbh, bbj),
+//	[bbj, cca), [cca, xxe), [xxe, xxz), [xxz, )
 func TestSplitAndScatter(t *testing.T) {
 	t.Run("BatchScatter", func(t *testing.T) {
 		client := initTestClient(false)
@@ -474,8 +475,9 @@ func initRewriteRules() *restore.RewriteRules {
 }
 
 // expected regions after split:
-//   [, aay), [aay, bba), [bba, bbf), [bbf, bbh), [bbh, bbj),
-//   [bbj, cca), [cca, xxe), [xxe, xxz), [xxz, )
+//
+//	[, aay), [aay, bba), [bba, bbf), [bbf, bbh), [bbh, bbj),
+//	[bbj, cca), [cca, xxe), [xxe, xxz), [xxz, )
 func validateRegions(regions map[uint64]*split.RegionInfo) bool {
 	keys := [...]string{"", "aay", "bba", "bbf", "bbh", "bbj", "cca", "xxe", "xxz", ""}
 	return validateRegionsExt(regions, keys[:], false)

br/pkg/restore/stream_metas.go

@@ -85,10 +85,12 @@ func (ms *StreamMetadataSet) CalculateShiftTS(startTS uint64) uint64 {
 }
 
 // IterateFilesFullyBefore runs the function over all files contain data before the timestamp only.
-//   0                                          before
-//   |------------------------------------------|
-//    |-file1---------------| <- File contains records in this TS range would be found.
-//                                  |-file2--------------| <- File contains any record out of this won't be found.
+//
+//	0                                          before
+//	|------------------------------------------|
+//	 |-file1---------------| <- File contains records in this TS range would be found.
+//	                               |-file2--------------| <- File contains any record out of this won't be found.
+//
 // This function would call the `f` over file1 only.
 func (ms *StreamMetadataSet) IterateFilesFullyBefore(before uint64, f func(d *backuppb.DataFileInfo) (shouldBreak bool)) {
 	ms.iterateDataFiles(func(d *backuppb.DataFileInfo) (shouldBreak bool) {

br/pkg/stream/stream_status.go

@@ -255,7 +255,8 @@ type PDInfoProvider interface {
 
 // MaybeQPS get a number like the QPS of last seconds for each store via the prometheus interface.
 // TODO: this is a temporary solution(aha, like in a Hackthon),
-//       we MUST find a better way for providing this information.
+//
+//	we MUST find a better way for providing this information.
 func MaybeQPS(ctx context.Context, mgr PDInfoProvider) (float64, error) {
 	c := mgr.GetPDClient()
 	prefix := "http://"

br/pkg/streamhelper/advancer.go

@@ -29,23 +29,25 @@ import (
 // CheckpointAdvancer is the central node for advancing the checkpoint of log backup.
 // It's a part of "checkpoint v3".
 // Generally, it scan the regions in the task range, collect checkpoints from tikvs.
-//                                         ┌──────┐
-//                                   ┌────►│ TiKV │
-//                                   │     └──────┘
-//                                   │
-//                                   │
-// ┌──────────┐GetLastFlushTSOfRegion│     ┌──────┐
-// │ Advancer ├──────────────────────┼────►│ TiKV │
-// └────┬─────┘                      │     └──────┘
-//      │                            │
-//      │                            │
-//      │                            │     ┌──────┐
-//      │                            └────►│ TiKV │
-//      │                                  └──────┘
-//      │
-//      │ UploadCheckpointV3   ┌──────────────────┐
-//      └─────────────────────►│  PD              │
-//                             └──────────────────┘
+/*
+                                         ┌──────┐
+                                   ┌────►│ TiKV │
+                                   │     └──────┘
+                                   │
+                                   │
+ ┌──────────┐GetLastFlushTSOfRegion│     ┌──────┐
+ │ Advancer ├──────────────────────┼────►│ TiKV │
+ └────┬─────┘                      │     └──────┘
+      │                            │
+      │                            │
+      │                            │     ┌──────┐
+      │                            └────►│ TiKV │
+      │                                  └──────┘
+      │
+      │ UploadCheckpointV3   ┌──────────────────┐
+      └─────────────────────►│  PD              │
+                             └──────────────────┘
+*/
 type CheckpointAdvancer struct {
 	env Env
 

br/pkg/streamhelper/advancer_daemon.go

@@ -26,9 +26,11 @@ const (
 //
 // ad := NewAdvancerDaemon(adv, mgr)
 // loop, err := ad.Begin(ctx)
-// if err != nil {
-//   return err
-// }
+//
+//	if err != nil {
+//	  return err
+//	}
+//
 // loop()
 type AdvancerDaemon struct {
 	adv     *CheckpointAdvancer

br/pkg/streamhelper/collector.go

@@ -221,19 +221,21 @@ type runningStoreCollector struct {
 
 // clusterCollector is the controller for collecting region checkpoints for the cluster.
 // It creates multi store collectors.
-//                             ┌──────────────────────┐ Requesting   ┌────────────┐
-//                          ┌─►│ StoreCollector[id=1] ├─────────────►│ TiKV[id=1] │
-//                          │  └──────────────────────┘              └────────────┘
-//                          │
-//                          │Owns
-// ┌──────────────────┐     │  ┌──────────────────────┐ Requesting   ┌────────────┐
-// │ ClusterCollector ├─────┼─►│ StoreCollector[id=4] ├─────────────►│ TiKV[id=4] │
-// └──────────────────┘     │  └──────────────────────┘              └────────────┘
-//                          │
-//                          │
-//                          │  ┌──────────────────────┐ Requesting   ┌────────────┐
-//                          └─►│ StoreCollector[id=5] ├─────────────►│ TiKV[id=5] │
-//                             └──────────────────────┘              └────────────┘
+/*
+                             ┌──────────────────────┐ Requesting   ┌────────────┐
+                          ┌─►│ StoreCollector[id=1] ├─────────────►│ TiKV[id=1] │
+                          │  └──────────────────────┘              └────────────┘
+                          │
+                          │Owns
+ ┌──────────────────┐     │  ┌──────────────────────┐ Requesting   ┌────────────┐
+ │ ClusterCollector ├─────┼─►│ StoreCollector[id=4] ├─────────────►│ TiKV[id=4] │
+ └──────────────────┘     │  └──────────────────────┘              └────────────┘
+                          │
+                          │
+                          │  ┌──────────────────────┐ Requesting   ┌────────────┐
+                          └─►│ StoreCollector[id=5] ├─────────────►│ TiKV[id=5] │
+                             └──────────────────────┘              └────────────┘
+*/
 type clusterCollector struct {
 	mu         sync.Mutex
 	collectors map[uint64]runningStoreCollector

br/pkg/streamhelper/tsheap.go

@@ -30,11 +30,12 @@ import (
 //   - is based on range (it only promises there won't be new committed txns in the range).
 //   - the checkpoint of union of ranges is the minimal checkpoint of all ranges.
 // As an example:
-// +----------------------------------+
-// ^-----------^ (Checkpoint = 42)
-//         ^---------------^ (Checkpoint = 76)
-// ^-----------------------^ (Checkpoint = min(42, 76) = 42)
-//
+/*
+ +----------------------------------+
+ ^-----------^ (Checkpoint = 42)
+         ^---------------^ (Checkpoint = 76)
+ ^-----------------------^ (Checkpoint = min(42, 76) = 42)
+*/
 // For calculating the global checkpoint, we can make a heap-like structure:
 // Checkpoint    Ranges
 // 42         -> {[0, 8], [16, 100]}

br/pkg/task/stream.go

@@ -425,7 +425,7 @@ func (s *streamMgr) backupFullSchemas(ctx context.Context, g glue.Glue) error {
 	return nil
 }
 
-// RunStreamCommand run all kinds of `stream task``
+// RunStreamCommand run all kinds of `stream task`
 func RunStreamCommand(
 	ctx context.Context,
 	g glue.Glue,

br/pkg/utils/worker.go

@@ -114,15 +114,15 @@ func (pool *WorkerPool) HasWorker() bool {
 // PanicToErr recovers when the execution get panicked, and set the error provided by the arg.
 // generally, this would be used with named return value and `defer`, like:
 //
-// func foo() (err error) {
-//   defer utils.PanicToErr(&err)
-//   return maybePanic()
-// }
+//	func foo() (err error) {
+//	  defer utils.PanicToErr(&err)
+//	  return maybePanic()
+//	}
 //
 // Before using this, there are some hints for reducing resource leakage or bugs:
-// - If any of clean work (by `defer`) relies on the error (say, when error happens, rollback some operations.), please
-//   place `defer this` AFTER that.
-// - All resources allocated should be freed by the `defer` syntax, or when panicking, they may not be recycled.
+//   - If any of clean work (by `defer`) relies on the error (say, when error happens, rollback some operations.), please
+//     place `defer this` AFTER that.
+//   - All resources allocated should be freed by the `defer` syntax, or when panicking, they may not be recycled.
 func PanicToErr(err *error) {
 	item := recover()
 	if item != nil {

br/tests/br_key_locked/locker.go

@@ -185,6 +185,7 @@ type Locker struct {
 }
 
 // generateLocks sends Prewrite requests to TiKV to generate locks, without committing and rolling back.
+//
 //nolint:gosec
 func (c *Locker) generateLocks(pctx context.Context) error {
 	log.Info("genLock started")

build/linter/util/util.go

@@ -27,7 +27,6 @@ import (
 	"honnef.co/go/tools/analysis/report"
 )
 
-//
 type skipType int
 
 const (