enable forcetypeassert linter

.golangci.yml

@@ -227,7 +227,6 @@ linters:
     - exhaustivestruct
     - exhaustruct
     - forbidigo
-    - forcetypeassert
     - funlen
     - gochecknoglobals
     - gocognit

CHANGELOG.md

@@ -1,3 +1,5 @@
+* Added type assertion checks to enhance type safety and prevent unexpected panics in critical sections of the codebase
+
 ## v3.65.0
 * Supported OAuth 2.0 Token Exchange credentials provider
 

internal/allocator/allocator.go

@@ -1,6 +1,7 @@
 package allocator
 
 import (
+	"fmt"
 	"sync"
 
 	"github.com/ydb-platform/ydb-go-genproto/protos/Ydb"
@@ -1107,7 +1108,12 @@ func (p *Pool[T]) Get() *T {
 		v = &zero
 	}
 
-	return v.(*T)
+	val, ok := v.(*T)
+	if !ok {
+		panic(fmt.Sprintf("assertion failed: expected type *T, got %T", v))
+	}
+
+	return val
 }
 
 func (p *Pool[T]) Put(t *T) {

internal/bind/numeric_args.go

@@ -56,7 +56,11 @@ func (m NumericArgs) RewriteQuery(sql string, args ...interface{}) (yql string,
 				)
 			}
 			paramIndex := int(p - 1)
-			buffer.WriteString(newArgs[paramIndex].(table.ParameterOption).Name())
+			val, ok := newArgs[paramIndex].(table.ParameterOption)
+			if !ok {
+				panic(fmt.Sprintf("unsupported type conversion from %T to table.ParameterOption", val))
+			}
+			buffer.WriteString(val.Name())
 		}
 	}
 

internal/cmd/gtrace/writer.go

@@ -86,7 +86,10 @@ func (w *Writer) init() {
 }
 
 func (w *Writer) mustDeclare(name string) {
-	s := w.scope.Back().Value.(*scope)
+	s, ok := w.scope.Back().Value.(*scope)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to w.scope.Back()", s))
+	}
 	if !s.set(name) {
 		where := s.where(name)
 		panic(fmt.Sprintf(
@@ -100,7 +103,10 @@ func (w *Writer) declare(name string) string {
 	if isPredeclared(name) {
 		name = firstChar(name)
 	}
-	s := w.scope.Back().Value.(*scope)
+	s, ok := w.scope.Back().Value.(*scope)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to *scope", s))
+	}
 	for i := 0; ; i++ {
 		v := name
 		if i > 0 {
@@ -127,7 +133,10 @@ func (w *Writer) isGlobalScope() bool {
 }
 
 func (w *Writer) capture(vars ...string) {
-	s := w.scope.Back().Value.(*scope)
+	s, ok := w.scope.Back().Value.(*scope)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to *scope", s))
+	}
 	for _, v := range vars {
 		if !s.set(v) {
 			panic(fmt.Sprintf("can't capture variable %q", v))

internal/conn/conn.go

@@ -565,7 +565,11 @@ func getContextMark(ctx context.Context) *modificationMark {
 		return &modificationMark{}
 	}
 
-	return v.(*modificationMark)
+	val, ok := v.(*modificationMark)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to *modificationMark", val))
+	}
+	return val
 }
 
 type modificationMark struct {

internal/credentials/oauth2_test.go

@@ -400,8 +400,19 @@ func TestJWTTokenSource(t *testing.T) {
 	require.NoError(t, parsedToken.Claims.Valid())
 	require.Equal(t, "test_issuer", claims.Issuer)
 	require.Equal(t, "test_audience", claims.Audience[0])
-	require.Equal(t, "key_id", parsedToken.Header["kid"].(string))
-	require.Equal(t, "RS256", parsedToken.Header["alg"].(string))
+
+	val, ok := parsedToken.Header["kid"].(string)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to string", val))
+	}
+	require.Equal(t, "key_id", val)
+
+	val, ok = parsedToken.Header["alg"].(string)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to string", val))
+	}
+	require.Equal(t, "RS256", val)
+
 }
 
 func TestJWTTokenBadParams(t *testing.T) {

internal/grpcwrapper/rawtopic/rawtopicwriter/streamwriter_test.go

@@ -1,6 +1,7 @@
 package rawtopicwriter
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -72,7 +73,11 @@ func TestSendWriteRequest(t *testing.T) {
 		}
 
 		getWriteRequest := func(req *Ydb_Topic.StreamWriteMessage_FromClient) *Ydb_Topic.StreamWriteMessage_WriteRequest {
-			return req.GetClientMessage().(*Ydb_Topic.StreamWriteMessage_FromClient_WriteRequest).WriteRequest
+			res, ok := req.ClientMessage.(*Ydb_Topic.StreamWriteMessage_FromClient_WriteRequest)
+			if !ok {
+				panic(fmt.Sprintf("unsupported type conversion from %T to *Ydb_Topic.StreamWriteMessage_FromClient_WriteRequest", res))
+			}
+			return res.WriteRequest
 		}
 
 		sendCounter := 0

internal/table/client.go

@@ -615,12 +615,18 @@ func (c *Client) Close(ctx context.Context) (err error) {
 			c.limit = 0
 
 			for el := c.waitQ.Front(); el != nil; el = el.Next() {
-				ch := el.Value.(*chan *session)
+				ch, ok := el.Value.(*chan *session)
+				if !ok {
+					panic(fmt.Sprintf("unsupported type conversion from %T to *chan *session", ch))
+				}
 				close(*ch)
 			}
 
 			for e := c.idle.Front(); e != nil; e = e.Next() {
-				s := e.Value.(*session)
+				s, ok := e.Value.(*session)
+				if !ok {
+					panic(fmt.Sprintf("unsupported type conversion from %T to *session", s))
+				}
 				s.SetStatus(table.SessionClosing)
 				c.wg.Add(1)
 				go func() {
@@ -745,7 +751,10 @@ func (c *Client) internalPoolGCTick(ctx context.Context, idleThreshold time.Dura
 			return
 		}
 		for e := c.idle.Front(); e != nil; e = e.Next() {
-			s := e.Value.(*session)
+			s, ok := e.Value.(*session)
+			if !ok {
+				panic(fmt.Sprintf("unsupported type conversion from %T to *session", s))
+			}
 			info, has := c.index[s]
 			if !has {
 				panic("session not found in pool")
@@ -818,7 +827,10 @@ func (c *Client) internalPoolPeekFirstIdle() (s *session, touched time.Time) {
 	if el == nil {
 		return
 	}
-	s = el.Value.(*session)
+	s, ok := el.Value.(*session)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to *session", s))
+	}
 	info, has := c.index[s]
 	if !has || el != info.idle {
 		panic("inconsistent session client index")
@@ -857,7 +869,10 @@ func (c *Client) internalPoolNotify(s *session) (notified bool) {
 		// missed something and may want to retry (especially for case (3)).
 		//
 		// After that we taking a next waiter and repeat the same.
-		ch := c.waitQ.Remove(el).(*chan *session)
+		ch, ok := c.waitQ.Remove(el).(*chan *session)
+		if !ok {
+			panic(fmt.Sprintf("unsupported type conversion from %T to *chan *session", ch))
+		}
 		select {
 		case *ch <- s:
 			// Case (1).

internal/table/client_test.go

@@ -912,7 +912,10 @@ func (s *StubBuilder) createSession(ctx context.Context) (session *session, err
 func (c *Client) debug() {
 	fmt.Print("head ")
 	for el := c.idle.Front(); el != nil; el = el.Next() {
-		s := el.Value.(*session)
+		s, ok := el.Value.(*session)
+		if !ok {
+			panic(fmt.Sprintf("unsupported type conversion from %T to *session", s))
+		}
 		x := c.index[s]
 		fmt.Printf("<-> %s(%d) ", s.ID(), x.touched.Unix())
 	}

internal/table/retry_test.go

@@ -160,7 +160,11 @@ func TestRetryerSessionClosing(t *testing.T) {
 			config.New(),
 			func(ctx context.Context, s table.Session) error {
 				sessions = append(sessions, s)
-				s.(*session).SetStatus(table.SessionClosing)
+				val, ok := s.(*session)
+				if !ok {
+					panic(fmt.Sprintf("unsupported type conversion from %T to *session", val))
+				}
+				val.SetStatus(table.SessionClosing)
 
 				return nil
 			},

internal/table/scanner/result_test.go

@@ -264,18 +264,34 @@ func TestNewStreamWithRecvFirstResultSet(t *testing.T) {
 				require.NoError(t, err)
 				require.NotNil(t, result)
 				require.EqualValues(t, 1, tt.recvCounter)
-				require.EqualValues(t, 1, result.(*streamResult).nextResultSetCounter.Load())
+
+				val, ok := result.(*streamResult)
+				if !ok {
+					panic(fmt.Sprintf("unsupported type conversion from %T to *streamResult", val))
+				}
+				require.EqualValues(t, 1, val.nextResultSetCounter.Load())
+
 				for i := range make([]struct{}, 1000) {
 					err = result.NextResultSetErr(tt.ctx)
 					require.NoError(t, err)
 					require.Equal(t, i+1, tt.recvCounter)
-					require.Equal(t, i+2, int(result.(*streamResult).nextResultSetCounter.Load()))
+
+					val, ok := result.(*streamResult)
+					if !ok {
+						panic(fmt.Sprintf("unsupported type conversion from %T to *streamResult", val))
+					}
+					require.Equal(t, i+2, int(val.nextResultSetCounter.Load()))
 				}
 				err = result.NextResultSetErr(tt.ctx)
 				require.ErrorIs(t, err, io.EOF)
 				require.True(t, err == io.EOF) //nolint:errorlint,testifylint
 				require.Equal(t, 1001, tt.recvCounter)
-				require.Equal(t, 1002, int(result.(*streamResult).nextResultSetCounter.Load()))
+
+				val, ok = result.(*streamResult)
+				if !ok {
+					panic(fmt.Sprintf("unsupported type conversion from %T to *streamResult", val))
+				}
+				require.Equal(t, 1002, int(val.nextResultSetCounter.Load()))
 			}
 		})
 	}

internal/table/scanner/scan_raw.go

@@ -2,6 +2,7 @@ package scanner
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"reflect"
 	"strconv"
@@ -584,8 +585,10 @@ func (s *rawConverter) IsDecimal() bool {
 }
 
 func isEqualDecimal(d *Ydb.DecimalType, t types.Type) bool {
-	w := t.(*types.Decimal)
-
+	w, ok := t.(*types.Decimal)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to *types.Decimal", w))
+	}
 	return d.GetPrecision() == w.Precision() && d.GetScale() == w.Scale()
 }
 

internal/table/session_test.go

@@ -462,7 +462,11 @@ func TestCreateTableRegression(t *testing.T) {
 							"attr": "attr_value",
 						},
 					}
-					if !proto.Equal(exp, act.(proto.Message)) {
+					val, ok := act.(proto.Message)
+					if !ok {
+						panic(fmt.Sprintf("unsupported type conversion from %T to proto.Message", val))
+					}
+					if !proto.Equal(exp, val) {
 						//nolint:revive
 						return nil, fmt.Errorf("proto's not equal: \n\nact: %v\n\nexp: %s\n\n", act, exp)
 					}

internal/table/transaction.go

@@ -98,10 +98,15 @@ func (tx *transaction) ExecuteStatement(
 	a := allocator.New()
 	defer a.Free()
 
+	val, ok := stmt.(*statement)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to *statement", val))
+	}
+
 	onDone := trace.TableOnTxExecuteStatement(
 		tx.s.config.Trace(), &ctx,
 		stack.FunctionID("github.com/ydb-platform/ydb-go-sdk/3/internal/table.(*transaction).ExecuteStatement"),
-		tx.s, tx, stmt.(*statement).query, parameters,
+		tx.s, tx, val.query, parameters,
 	)
 	defer func() {
 		onDone(r, err)

internal/topic/topicreaderinternal/batcher_test.go

@@ -3,6 +3,7 @@ package topicreaderinternal
 import (
 	"context"
 	"errors"
+	"fmt"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -339,10 +340,15 @@ func TestBatcherConcurency(t *testing.T) {
 		for i := 0; i < count; i++ {
 			res, err := b.Pop(ctx, batcherGetOptions{MinCount: 1})
 			require.NoError(tb, err)
+
+			val, ok := res.RawMessage.(*rawtopicreader.StartPartitionSessionRequest)
+			if !ok {
+				panic(fmt.Sprintf("unsupported type conversion from %T to *rawtopicreader.StartPartitionSessionRequest", val))
+			}
 			require.Equal(
 				tb,
 				rawtopicreader.NewOffset(int64(i)),
-				res.RawMessage.(*rawtopicreader.StartPartitionSessionRequest).CommittedOffset,
+				val.CommittedOffset,
 			)
 		}
 	})

internal/topic/topicreaderinternal/committer_test.go

@@ -3,6 +3,7 @@ package topicreaderinternal
 import (
 	"context"
 	"errors"
+	"fmt"
 	"testing"
 	"time"
 
@@ -231,7 +232,11 @@ func TestCommitterBuffer(t *testing.T) {
 		c.clock = clock
 		c.BufferTimeLagTrigger = time.Second
 		c.send = func(msg rawtopicreader.ClientMessage) error {
-			commitMess := msg.(*rawtopicreader.CommitOffsetRequest)
+			commitMess, ok := msg.(*rawtopicreader.CommitOffsetRequest)
+			if !ok {
+				panic(fmt.Sprintf("unsupported type conversion from %T to *rawtopicreader.CommitOffsetRequest", commitMess))
+			}
+
 			require.Len(t, commitMess.CommitOffsets, 2)
 			close(sendCalled)
 
@@ -264,7 +269,10 @@ func TestCommitterBuffer(t *testing.T) {
 		c.BufferTimeLagTrigger = time.Second // for prevent send
 		c.BufferCountTrigger = 2
 		c.send = func(msg rawtopicreader.ClientMessage) error {
-			commitMess := msg.(*rawtopicreader.CommitOffsetRequest)
+			commitMess, ok := msg.(*rawtopicreader.CommitOffsetRequest)
+			if !ok {
+				panic(fmt.Sprintf("unsupported type conversion from %T to *rawtopicreader.CommitOffsetRequest", commitMess))
+			}
 			require.Len(t, commitMess.CommitOffsets, 4)
 			close(sendCalled)
 
@@ -299,7 +307,10 @@ func TestCommitterBuffer(t *testing.T) {
 		c.BufferTimeLagTrigger = time.Second // for prevent send
 		c.BufferCountTrigger = 4
 		c.send = func(msg rawtopicreader.ClientMessage) error {
-			commitMess := msg.(*rawtopicreader.CommitOffsetRequest)
+			commitMess, ok := msg.(*rawtopicreader.CommitOffsetRequest)
+			if !ok {
+				panic(fmt.Sprintf("unsupported type conversion from %T to *rawtopicreader.CommitOffsetRequest", commitMess))
+			}
 			require.Len(t, commitMess.CommitOffsets, 4)
 			close(sendCalled)
 

internal/topic/topicwriterinternal/writer_grpc_mock_test.go

@@ -101,8 +101,12 @@ func (t *topicWriterOperationUnavailable) StreamWrite(server Ydb_Topic_V1.TopicS
 		return errors.New("failed to read messages block")
 	}
 
-	if len(messagesMsg.GetClientMessage().(*Ydb_Topic.StreamWriteMessage_FromClient_WriteRequest).
-		WriteRequest.GetMessages()) == 0 {
+	val, ok := messagesMsg.GetClientMessage().(*Ydb_Topic.StreamWriteMessage_FromClient_WriteRequest)
+	if !ok {
+		panic(fmt.Sprintf("unsupported type conversion from %T to *Ydb_Topic.StreamWriteMessage_FromClient_WriteRequest", val))
+	}
+
+	if len(val.WriteRequest.GetMessages()) == 0 {
 		return errors.New("received zero messages block")
 	}