Merge pull request #1023 from ShishkovEM/master

asmyasnikov · web-flow · commit cf01642242a7 · 2024-05-23T19:55:19.000+03:00
enable ifshort linter
diff --git a/.golangci.yml b/.golangci.yml
@@ -232,7 +232,6 @@ linters:
     - godot
     - goerr113
     - golint
-    - ifshort
     - interfacebloat
     - ireturn
     - maintidx
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,4 +1,6 @@
-## v3.68.0
+* Refactored internal packages by `ifshort` linter issues
+
+# v3.68.0
 * Added experimental `ydb.{Register,Unregister}DsnParser` global funcs for register/unregister external custom DSN parser for `ydb.Open` and `sql.Open` driver constructor
 * Simple implement option WithReaderWithoutConsumer
 * Fixed bug: topic didn't send specified partition number to a server 
diff --git a/examples/basic/native/table/series.go b/examples/basic/native/table/series.go
@@ -409,8 +409,7 @@ func describeTable(ctx context.Context, c table.Client, path string) error {
 
 func render(t *template.Template, data interface{}) string {
 	var buf bytes.Buffer
-	err := t.Execute(&buf, data)
-	if err != nil {
+	if err := t.Execute(&buf, data); err != nil {
 		panic(err)
 	}
 
diff --git a/examples/decimal/decimal.go b/examples/decimal/decimal.go
@@ -30,8 +30,7 @@ SELECT value FROM decimals;
 
 func render(t *template.Template, data interface{}) string {
 	var buf bytes.Buffer
-	err := t.Execute(&buf, data)
-	if err != nil {
+	if err := t.Execute(&buf, data); err != nil {
 		panic(err)
 	}
 
diff --git a/examples/read_table/orders.go b/examples/read_table/orders.go
@@ -73,8 +73,7 @@ FROM AS_TABLE($ordersData);
 
 func render(t *template.Template, data interface{}) string {
 	var buf bytes.Buffer
-	err := t.Execute(&buf, data)
-	if err != nil {
+	if err := t.Execute(&buf, data); err != nil {
 		panic(err)
 	}
 
diff --git a/examples/serverless/url_shortener/service.go b/examples/serverless/url_shortener/service.go
@@ -41,8 +41,7 @@ var (
 
 func hash(s string) (string, error) {
 	hasher := fnv.New32a()
-	_, err := hasher.Write([]byte(s))
-	if err != nil {
+	if _, err := hasher.Write([]byte(s)); err != nil {
 		return "", err
 	}
 
@@ -59,8 +58,7 @@ func isLongCorrect(link string) bool {
 
 func render(t *template.Template, data interface{}) string {
 	var buf bytes.Buffer
-	err := t.Execute(&buf, data)
-	if err != nil {
+	if err := t.Execute(&buf, data); err != nil {
 		panic(err)
 	}
 
diff --git a/examples/topic/cdc-cache-bus-freeseats/main.go b/examples/topic/cdc-cache-bus-freeseats/main.go
@@ -27,11 +27,10 @@ var (
 func main() {
 	flag.Parse()
 
-	ctx := context.Background()
 	db := connect()
 
 	if !*skipCreateTable {
-		createTableAndCDC(ctx, db, *backendCount)
+		createTableAndCDC(context.Background(), db, *backendCount)
 	}
 
 	servers := make([]http.Handler, *backendCount)
diff --git a/internal/conn/conn.go b/internal/conn/conn.go
@@ -161,7 +161,7 @@ func (c *conn) setState(ctx context.Context, s State) State {
 func (c *conn) Unban(ctx context.Context) State {
 	var newState State
 	c.mtx.RLock()
-	cc := c.grpcConn
+	cc := c.grpcConn //nolint:ifshort
 	c.mtx.RUnlock()
 	if isAvailable(cc) {
 		newState = Online
diff --git a/internal/coordination/conversation/conversation.go b/internal/coordination/conversation/conversation.go
@@ -315,6 +315,8 @@ func (c *Controller) OnSend(ctx context.Context) (*Ydb_Coordination.SessionReque
 // OnRecv consumes a new conversation response and process with the corresponding conversation if any exists for it. The
 // returned value indicates if any conversation considers the incoming message part of it or the controller is closed.
 // You should call this method in the goroutine that handles gRPC stream Recv method.
+//
+//nolint:ifshort // false-positive this var is used outside if statement in switch-case up
 func (c *Controller) OnRecv(resp *Ydb_Coordination.SessionResponse) bool {
 	c.mutex.Lock()
 	defer c.mutex.Unlock()
diff --git a/internal/decimal/decimal.go b/internal/decimal/decimal.go
@@ -61,8 +61,7 @@ func FromBytes(bts []byte, precision, scale uint32) *big.Int {
 	}
 
 	v.SetBytes(bts)
-
-	neg := bts[0]&negMask != 0
+	neg := bts[0]&negMask != 0 //nolint:ifshort
 	if neg {
 		// Given bytes contains negative value.
 		// Interpret is as two's complement.
@@ -99,7 +98,7 @@ func Parse(s string, precision, scale uint32) (*big.Int, error) {
 		return v, nil
 	}
 
-	neg := s[0] == '-'
+	neg := s[0] == '-' //nolint:ifshort
 	if neg || s[0] == '+' {
 		s = s[1:]
 	}
@@ -212,7 +211,7 @@ func Format(x *big.Int, precision, scale uint32) string {
 	}
 
 	v := big.NewInt(0).Set(x)
-	neg := x.Sign() < 0
+	neg := x.Sign() < 0 //nolint:ifshort
 	if neg {
 		// Convert negative to positive.
 		v.Neg(x)
@@ -288,7 +287,7 @@ func BigIntToByte(x *big.Int, precision, scale uint32) (p [16]byte) {
 }
 
 func put(x *big.Int, p []byte) {
-	neg := x.Sign() < 0
+	neg := x.Sign() < 0 //nolint:ifshort
 	if neg {
 		x = complement(x)
 	}
diff --git a/internal/query/client.go b/internal/query/client.go
@@ -48,8 +48,7 @@ func (c *Client) Stats() *stats.Stats {
 func (c *Client) Close(ctx context.Context) error {
 	close(c.done)
 
-	err := c.pool.Close(ctx)
-	if err != nil {
+	if err := c.pool.Close(ctx); err != nil {
 		return xerrors.WithStackTrace(err)
 	}
 
diff --git a/internal/table/scanner/result.go b/internal/table/scanner/result.go
@@ -36,8 +36,7 @@ type streamResult struct {
 
 // Err returns error caused Scanner to be broken.
 func (r *streamResult) Err() error {
-	err := r.valueScanner.Err()
-	if err != nil {
+	if err := r.valueScanner.Err(); err != nil {
 		return xerrors.WithStackTrace(err)
 	}
 
@@ -53,8 +52,7 @@ type unaryResult struct {
 
 // Err returns error caused Scanner to be broken.
 func (r *unaryResult) Err() error {
-	err := r.valueScanner.Err()
-	if err != nil {
+	if err := r.valueScanner.Err(); err != nil {
 		return xerrors.WithStackTrace(err)
 	}
 
diff --git a/internal/table/scanner/scan_raw.go b/internal/table/scanner/scan_raw.go
@@ -685,9 +685,8 @@ func (s *rawConverter) boundsCheck(n, i int) bool {
 }
 
 func (s *valueScanner) assertTypeOptional(typ *Ydb.Type) (t *Ydb.Type_OptionalType) {
-	x := typ.GetType()
-	if t, _ = x.(*Ydb.Type_OptionalType); t == nil {
-		s.typeError(x, t)
+	if t, _ = typ.GetType().(*Ydb.Type_OptionalType); t == nil {
+		s.typeError(typ.GetType(), t)
 	}
 
 	return
@@ -749,54 +748,48 @@ func (s *rawConverter) assertCurrentTypeDecimal(t types.Type) bool {
 }
 
 func (s *rawConverter) assertTypeList(typ *Ydb.Type) (t *Ydb.Type_ListType) {
-	x := typ.GetType()
-	if t, _ = x.(*Ydb.Type_ListType); t == nil {
-		s.typeError(x, t)
+	if t, _ = typ.GetType().(*Ydb.Type_ListType); t == nil {
+		s.typeError(typ.GetType(), t)
 	}
 
 	return
 }
 
 func (s *rawConverter) assertTypeTuple(typ *Ydb.Type) (t *Ydb.Type_TupleType) {
-	x := typ.GetType()
-	if t, _ = x.(*Ydb.Type_TupleType); t == nil {
-		s.typeError(x, t)
+	if t, _ = typ.GetType().(*Ydb.Type_TupleType); t == nil {
+		s.typeError(typ.GetType(), t)
 	}
 
 	return
 }
 
 func (s *rawConverter) assertTypeStruct(typ *Ydb.Type) (t *Ydb.Type_StructType) {
-	x := typ.GetType()
-	if t, _ = x.(*Ydb.Type_StructType); t == nil {
-		s.typeError(x, t)
+	if t, _ = typ.GetType().(*Ydb.Type_StructType); t == nil {
+		s.typeError(typ.GetType(), t)
 	}
 
 	return
 }
 
 func (s *rawConverter) assertTypeDict(typ *Ydb.Type) (t *Ydb.Type_DictType) {
-	x := typ.GetType()
-	if t, _ = x.(*Ydb.Type_DictType); t == nil {
-		s.typeError(x, t)
+	if t, _ = typ.GetType().(*Ydb.Type_DictType); t == nil {
+		s.typeError(typ.GetType(), t)
 	}
 
 	return
 }
 
 func (s *rawConverter) assertTypeDecimal(typ *Ydb.Type) (t *Ydb.Type_DecimalType) {
-	x := typ.GetType()
-	if t, _ = x.(*Ydb.Type_DecimalType); t == nil {
-		s.typeError(x, t)
+	if t, _ = typ.GetType().(*Ydb.Type_DecimalType); t == nil {
+		s.typeError(typ.GetType(), t)
 	}
 
 	return
 }
 
 func (s *rawConverter) assertTypeVariant(typ *Ydb.Type) (t *Ydb.Type_VariantType) {
-	x := typ.GetType()
-	if t, _ = x.(*Ydb.Type_VariantType); t == nil {
-		s.typeError(x, t)
+	if t, _ = typ.GetType().(*Ydb.Type_VariantType); t == nil {
+		s.typeError(typ.GetType(), t)
 	}
 
 	return
diff --git a/internal/table/scanner/scanner.go b/internal/table/scanner/scanner.go
@@ -527,9 +527,8 @@ func (s *valueScanner) unwrapDecimal() decimal.Decimal {
 }
 
 func (s *valueScanner) assertTypeDecimal(typ *Ydb.Type) (t *Ydb.Type_DecimalType) {
-	x := typ.GetType()
-	if t, _ = x.(*Ydb.Type_DecimalType); t == nil {
-		s.typeError(x, t)
+	if t, _ = typ.GetType().(*Ydb.Type_DecimalType); t == nil {
+		s.typeError(typ.GetType(), t)
 	}
 
 	return
diff --git a/internal/topic/topicreaderinternal/stream_reconnector.go b/internal/topic/topicreaderinternal/stream_reconnector.go
@@ -253,8 +253,7 @@ func (r *readerReconnector) reconnect(ctx context.Context, reason error, oldRead
 		return err
 	}
 
-	stream, _ := r.stream(ctx)
-	if oldReader != stream {
+	if stream, _ := r.stream(ctx); oldReader != stream {
 		return xerrors.WithStackTrace(errReconnectRequestOutdated)
 	}
 
@@ -413,9 +412,7 @@ func (r *readerReconnector) stream(ctx context.Context) (batchedStreamReader, er
 }
 
 func (r *readerReconnector) handlePanic() {
-	p := recover()
-
-	if p != nil {
+	if p := recover(); p != nil {
 		_ = r.CloseWithError(context.Background(), xerrors.WithStackTrace(fmt.Errorf("handled panic: %v", p)))
 	}
 }
diff --git a/internal/topic/topicwriterinternal/message.go b/internal/topic/topicwriterinternal/message.go
@@ -188,8 +188,7 @@ func (m *messageWithDataContent) getRawBytes() ([]byte, error) {
 		return nil, xerrors.WithStackTrace(errNoRawContent)
 	}
 
-	err := m.readDataToRawBuf()
-	if err != nil {
+	if err := m.readDataToRawBuf(); err != nil {
 		return nil, err
 	}
 
diff --git a/internal/topic/topicwriterinternal/writer_reconnector.go b/internal/topic/topicwriterinternal/writer_reconnector.go
@@ -331,7 +331,7 @@ func (w *WriterReconnector) Close(ctx context.Context) error {
 	reason := xerrors.WithStackTrace(errStopWriterReconnector)
 	w.queue.StopAddNewMessages(reason)
 
-	flushErr := w.Flush(ctx)
+	flushErr := w.Flush(ctx) //nolint:ifshort
 	closeErr := w.close(ctx, reason)
 
 	if flushErr != nil {
diff --git a/internal/topic/topicwriterinternal/writer_single_stream.go b/internal/topic/topicwriterinternal/writer_single_stream.go
@@ -66,12 +66,13 @@ func NewSingleStreamWriter(
 	cfg SingleStreamWriterConfig, //nolint:gocritic
 ) (*SingleStreamWriter, error) {
 	res := newSingleStreamWriterStopped(ctxForPProfLabelsOnly, cfg)
-	err := res.initStream()
-	if err != nil {
+
+	if err := res.initStream(); err != nil {
 		_ = res.close(context.Background(), err)
 
 		return nil, err
 	}
+
 	res.start()
 
 	return res, nil
diff --git a/internal/xsql/tx.go b/internal/xsql/tx.go
@@ -89,8 +89,7 @@ func (tx *tx) Commit() (finalErr error) {
 	defer func() {
 		tx.conn.currentTx = nil
 	}()
-	_, err := tx.tx.CommitTx(tx.ctx)
-	if err != nil {
+	if _, err := tx.tx.CommitTx(tx.ctx); err != nil {
 		return badconn.Map(xerrors.WithStackTrace(err))
 	}
 
diff --git a/tests/slo/internal/config/config.go b/tests/slo/internal/config/config.go
@@ -115,8 +115,7 @@ func New() (*Config, error) {
 
 	fs.IntVar(&cfg.WriteTimeout, "write-timeout", 10000, "write timeout milliseconds")
 
-	err := fs.Parse(os.Args[4:])
-	if err != nil {
+	if err := fs.Parse(os.Args[4:]); err != nil {
 		return nil, err
 	}
 
diff --git a/tests/slo/internal/generator/generator.go b/tests/slo/internal/generator/generator.go
@@ -49,8 +49,7 @@ func (g *Generator) genPayloadString() (*string, error) {
 
 	sl := make([]byte, l)
 
-	_, err := crypto.Read(sl)
-	if err != nil {
+	if _, err := crypto.Read(sl); err != nil {
 		return nil, err
 	}
 
diff --git a/tests/slo/native/table/storage.go b/tests/slo/native/table/storage.go
@@ -238,8 +238,7 @@ func (s *Storage) createTable(ctx context.Context) error {
 }
 
 func (s *Storage) dropTable(ctx context.Context) error {
-	err := ctx.Err()
-	if err != nil {
+	if err := ctx.Err(); err != nil {
 		return err
 	}
 
diff --git a/testutil/compare.go b/testutil/compare.go
@@ -290,9 +290,8 @@ func compareBytes(l, r *Ydb.Value) int {
 }
 
 func compareBool(l, r *Ydb.Value) int {
-	ll := l.GetBoolValue()
-	rr := r.GetBoolValue()
-	if ll {
+	rr := r.GetBoolValue() //nolint:ifshort
+	if ll := l.GetBoolValue(); ll {
 		if rr {
 			return 0
 		}
diff --git a/testutil/compare_test.go b/testutil/compare_test.go
@@ -22,8 +22,7 @@ func TestUnwrapOptionalValue(t *testing.T) {
 		t.Errorf("Types are different: expected %d, actual %d", Ydb.Type_UTF8, typeID)
 	}
 	textValue := val.GetValue().GetValue().(*Ydb.Value_TextValue)
-	text := textValue.TextValue
-	if text != "a" {
+	if text := textValue.TextValue; text != "a" {
 		t.Errorf("Values are different: expected %q, actual %q", "a", text)
 	}
 }
@@ -38,8 +37,7 @@ func TestUnwrapPrimitiveValue(t *testing.T) {
 		t.Errorf("Types are different: expected %d, actual %d", Ydb.Type_UTF8, typeID)
 	}
 	textValue := val.GetValue().GetValue().(*Ydb.Value_TextValue)
-	text := textValue.TextValue
-	if text != "a" {
+	if text := textValue.TextValue; text != "a" {
 		t.Errorf("Values are different: expected %q, actual %q", "a", text)
 	}
 }
@@ -349,8 +347,7 @@ func TestIncompatiblePrimitives(t *testing.T) {
 func TestIncompatibleTuples(t *testing.T) {
 	l := value.TupleValue(value.Uint64Value(1), value.TextValue("abc"))
 	r := value.TupleValue(value.Uint64Value(1), value.BytesValue([]byte("abc")))
-	_, err := Compare(l, r)
-	if err == nil {
+	if _, err := Compare(l, r); err == nil {
 		t.Error("WithStackTrace expected")
 	} else if !errors.Is(err, ErrNotComparable) {
 		t.Errorf("Unexpected error: %v", err)

Original file line number	Diff line number	Diff line change
`@@ -409,8 +409,7 @@ func describeTable(ctx context.Context, c table.Client, path string) error {`
`409`	`409`
`410`	`410`	`func render(t *template.Template, data interface{}) string {`
`411`	`411`	`var buf bytes.Buffer`
`412`		`- err := t.Execute(&buf, data)`
`413`		`- if err != nil {`
	`412`	`+ if err := t.Execute(&buf, data); err != nil {`
`414`	`413`	`panic(err)`
`415`	`414`	`}`
`416`	`415`
Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,7 @@ SELECT value FROM decimals;`
`30`	`30`
`31`	`31`	`func render(t *template.Template, data interface{}) string {`
`32`	`32`	`var buf bytes.Buffer`
`33`		`- err := t.Execute(&buf, data)`
`34`		`- if err != nil {`
	`33`	`+ if err := t.Execute(&buf, data); err != nil {`
`35`	`34`	`panic(err)`
`36`	`35`	`}`
`37`	`36`
Original file line number	Diff line number	Diff line change
`@@ -73,8 +73,7 @@ FROM AS_TABLE($ordersData);`
`73`	`73`
`74`	`74`	`func render(t *template.Template, data interface{}) string {`
`75`	`75`	`var buf bytes.Buffer`
`76`		`- err := t.Execute(&buf, data)`
`77`		`- if err != nil {`
	`76`	`+ if err := t.Execute(&buf, data); err != nil {`
`78`	`77`	`panic(err)`
`79`	`78`	`}`
`80`	`79`
Original file line number	Diff line number	Diff line change
`@@ -61,8 +61,7 @@ func FromBytes(bts []byte, precision, scale uint32) *big.Int {`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`v.SetBytes(bts)`
`64`		`-`
`65`		`- neg := bts[0]&negMask != 0`
	`64`	`+ neg := bts[0]&negMask != 0 //nolint:ifshort`
`66`	`65`	`if neg {`
`67`	`66`	`// Given bytes contains negative value.`
`68`	`67`	`// Interpret is as two's complement.`
`@@ -99,7 +98,7 @@ func Parse(s string, precision, scale uint32) (*big.Int, error) {`
`99`	`98`	`return v, nil`
`100`	`99`	`}`
`101`	`100`
`102`		`- neg := s[0] == '-'`
	`101`	`+ neg := s[0] == '-' //nolint:ifshort`
`103`	`102`	`if neg \|\| s[0] == '+' {`
`104`	`103`	`s = s[1:]`
`105`	`104`	`}`
`@@ -212,7 +211,7 @@ func Format(x *big.Int, precision, scale uint32) string {`
`212`	`211`	`}`
`213`	`212`
`214`	`213`	`v := big.NewInt(0).Set(x)`
`215`		`- neg := x.Sign() < 0`
	`214`	`+ neg := x.Sign() < 0 //nolint:ifshort`
`216`	`215`	`if neg {`
`217`	`216`	`// Convert negative to positive.`
`218`	`217`	`v.Neg(x)`
`@@ -288,7 +287,7 @@ func BigIntToByte(x *big.Int, precision, scale uint32) (p [16]byte) {`
`288`	`287`	`}`
`289`	`288`
`290`	`289`	`func put(x *big.Int, p []byte) {`
`291`		`- neg := x.Sign() < 0`
	`290`	`+ neg := x.Sign() < 0 //nolint:ifshort`
`292`	`291`	`if neg {`
`293`	`292`	`x = complement(x)`
`294`	`293`	`}`