enable gocognit linter

.golangci.yml

@@ -230,7 +230,6 @@ linters:
     - forcetypeassert
     - funlen
     - gochecknoglobals
-    - gocognit
     - godot
     - goerr113
     - golint

internal/backoff/backoff_test.go

@@ -9,6 +9,12 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+type exp struct {
+	eq  time.Duration
+	gte time.Duration
+	lte time.Duration
+}
+
 func TestDelays(t *testing.T) {
 	duration := func(s string) (d time.Duration) {
 		d, err := time.ParseDuration(s)
@@ -42,11 +48,6 @@ func TestDelays(t *testing.T) {
 }
 
 func TestLogBackoff(t *testing.T) {
-	type exp struct {
-		eq  time.Duration
-		gte time.Duration
-		lte time.Duration
-	}
 	for _, tt := range []struct {
 		backoff Backoff
 		exp     []exp
@@ -145,24 +146,28 @@ func TestLogBackoff(t *testing.T) {
 
 						continue
 					}
-					if gte := exp.gte; act <= gte {
-						t.Errorf(
-							"unexpected Backoff delay: %s; want >= %s",
-							act, gte,
-						)
-					}
-					if lte := exp.lte; act >= lte {
-						t.Errorf(
-							"unexpected Backoff delay: %s; want <= %s",
-							act, lte,
-						)
-					}
+					checkExpWithAct(t, exp, act)
 				}
 			}
 		})
 	}
 }
 
+func checkExpWithAct(t *testing.T, exp exp, act time.Duration) {
+	if gte := exp.gte; act <= gte {
+		t.Errorf(
+			"unexpected Backoff delay: %s; want >= %s",
+			act, gte,
+		)
+	}
+	if lte := exp.lte; act >= lte {
+		t.Errorf(
+			"unexpected Backoff delay: %s; want <= %s",
+			act, lte,
+		)
+	}
+}
+
 func TestFastSlowDelaysWithoutJitter(t *testing.T) {
 	for _, tt := range []struct {
 		name    string

internal/bind/params.go

@@ -179,30 +179,11 @@ func Params(args ...interface{}) (parameters []*params.Parameter, _ error) {
 	for i, arg := range args {
 		switch x := arg.(type) {
 		case driver.NamedValue:
-			if x.Name == "" {
-				switch xx := x.Value.(type) {
-				case *params.Parameters:
-					if len(args) > 1 {
-						return nil, xerrors.WithStackTrace(errMultipleQueryParameters)
-					}
-					parameters = *xx
-				case *params.Parameter:
-					parameters = append(parameters, xx)
-				default:
-					x.Name = fmt.Sprintf("$p%d", i)
-					param, err := toYdbParam(x.Name, x.Value)
-					if err != nil {
-						return nil, xerrors.WithStackTrace(err)
-					}
-					parameters = append(parameters, param)
-				}
-			} else {
-				param, err := toYdbParam(x.Name, x.Value)
-				if err != nil {
-					return nil, xerrors.WithStackTrace(err)
-				}
-				parameters = append(parameters, param)
+			driverNamedParams, err := checkDriverNamedValue(i, params, x, args)
+			if err != nil {
+				return nil, err
 			}
+			params = driverNamedParams
 		case sql.NamedArg:
 			if x.Name == "" {
 				return nil, xerrors.WithStackTrace(errUnnamedParam)
@@ -233,3 +214,40 @@ func Params(args ...interface{}) (parameters []*params.Parameter, _ error) {
 
 	return parameters, nil
 }
+
+// checkDriverNamedValue checks the driver.NamedValue and adds it to the params slice.
+func checkDriverNamedValue(
+	i int,
+	params []table.ParameterOption,
+	x driver.NamedValue,
+	args []interface{},
+) ([]table.ParameterOption, error) {
+	if x.Name == "" {
+		switch xx := x.Value.(type) {
+		case *table.QueryParameters:
+			if len(args) > 1 {
+				return nil, xerrors.WithStackTrace(errMultipleQueryParameters)
+			}
+			xx.Each(func(name string, v types.Value) {
+				params = append(params, table.ValueParam(name, v))
+			})
+		case table.ParameterOption:
+			params = append(params, xx)
+		default:
+			x.Name = fmt.Sprintf("$p%d", i)
+			param, err := toYdbParam(x.Name, x.Value)
+			if err != nil {
+				return nil, xerrors.WithStackTrace(err)
+			}
+			params = append(params, param)
+		}
+	} else {
+		param, err := toYdbParam(x.Name, x.Value)
+		if err != nil {
+			return nil, xerrors.WithStackTrace(err)
+		}
+		params = append(params, param)
+	}
+
+	return params, nil
+}

internal/cmd/gtrace/main.go

@@ -142,6 +142,30 @@ func main() {
 	if err != nil {
 		panic(fmt.Sprintf("type error: %v", err))
 	}
+	items := findGtraceGen(astFiles, pkgFiles, srcFilePath)
+	p := Package{
+		Package:          pkg,
+		BuildConstraints: buildConstraints,
+	}
+	traces := make(map[string]*Trace)
+	for _, item := range items {
+		t := &Trace{
+			Name: item.Ident.Name,
+		}
+		p.Traces = append(p.Traces, t)
+		traces[item.Ident.Name] = t
+	}
+	extractNameAndDetails(items, &p, info, traces)
+	checkErrsInWriters(writers, p)
+
+	log.Println("OK")
+}
+
+// findGtraceGen iterates over the astFiles and pkgFiles to find elements marked with a comment containing "gtrace:gen"
+// and collects them into GenItems.
+//
+//nolint:gocognit
+func findGtraceGen(astFiles []*ast.File, pkgFiles []*os.File, srcFilePath string) []*GenItem {
 	var items []*GenItem
 	for i, astFile := range astFiles {
 		if pkgFiles[i].Name() != srcFilePath {
@@ -151,66 +175,72 @@ func main() {
 			depth int
 			item  *GenItem
 		)
-		ast.Inspect(astFile, func(n ast.Node) (next bool) {
-			if n == nil {
-				item = nil
-				depth--
+		ast.Inspect(astFile,
+			func(n ast.Node) (next bool) {
+				if n == nil {
+					item = nil
+					depth--
 
-				return true
-			}
-			defer func() {
-				if next {
-					depth++
+					return true
 				}
-			}()
+				defer func() {
+					if next {
+						depth++
+					}
+				}()
 
-			switch v := n.(type) {
-			case *ast.FuncDecl, *ast.ValueSpec:
-				return false
+				switch v := n.(type) {
+				case *ast.FuncDecl, *ast.ValueSpec:
+					return false
 
-			case *ast.Ident:
-				if item != nil {
-					item.Ident = v
-				}
+				case *ast.Ident:
+					if item != nil {
+						item.Ident = v
+					}
 
-				return false
+					return false
 
-			case *ast.CommentGroup:
-				for _, c := range v.List {
-					if strings.Contains(strings.TrimPrefix(c.Text, "//"), "gtrace:gen") {
-						if item == nil {
-							item = &GenItem{}
+				case *ast.CommentGroup:
+					for _, c := range v.List {
+						if strings.Contains(strings.TrimPrefix(c.Text, "//"), "gtrace:gen") {
+							if item == nil {
+								item = &GenItem{}
+							}
 						}
 					}
-				}
 
-				return false
+					return false
 
-			case *ast.StructType:
-				if item != nil {
-					item.StructType = v
-					items = append(items, item)
-					item = nil
-				}
+				case *ast.StructType:
+					if item != nil {
+						item.StructType = v
+						items = append(items, item)
+						item = nil
+					}
 
-				return false
-			}
+					return false
+				}
 
-			return true
-		})
-	}
-	p := Package{
-		Package:          pkg,
-		BuildConstraints: buildConstraints,
+				return true
+			},
+		)
 	}
-	traces := make(map[string]*Trace)
-	for _, item := range items {
-		t := &Trace{
-			Name: item.Ident.Name,
+
+	return items
+}
+
+// checkErrsInWriters iterate over each Writer in the writers slice and checks errors
+func checkErrsInWriters(writers []*Writer, p Package) {
+	for _, w := range writers {
+		if err := w.Write(p); err != nil {
+			panic(err)
 		}
-		p.Traces = append(p.Traces, t)
-		traces[item.Ident.Name] = t
 	}
+}
+
+// extractNameAndDetails extracts the name and details of functions from the given items, and populates the traces
+// in the package with hooks based on the extracted functions.
+func extractNameAndDetails(items []*GenItem, p *Package, info *types.Info, traces map[string]*Trace) {
 	for i, item := range items {
 		t := p.Traces[i]
 		for _, field := range item.StructType.Fields.List {
@@ -237,13 +267,6 @@ func main() {
 			})
 		}
 	}
-	for _, w := range writers {
-		if err := w.Write(p); err != nil {
-			panic(err)
-		}
-	}
-
-	log.Println("OK")
 }
 
 func buildFunc(info *types.Info, traces map[string]*Trace, fn *ast.FuncType) (ret *Func, err error) {