ci: Update workflow to use modern and maintainable Go version.

.github/workflows/test.yaml

@@ -1,51 +1,49 @@
 name: Tests
 
-on: [push, workflow_dispatch]
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
 
 jobs:
-  get-go-version:
-    name: Determine Go toolchain version
-    runs-on: ubuntu-latest
-    outputs:
-      go-version: ${{ steps.get-go-version.outputs.go-version }}
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
-      - name: Determine Go version
-        id: get-go-version
-        run: |
-          echo "Building with Go $(cat .go-version)"
-          echo "{go-version}={$(cat .go-version)}" >> $GITHUB_OUTPUT
-
   fmtcheck:
     name: format check
     runs-on: ubuntu-latest
-    needs: [get-go-version]
+    strategy:
+      matrix:
+        go-version:
+          - "oldstable"
+          - "stable"
     steps:
-      - name: Chekout Code
+      - name: Checkout Code
         uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
       - name: Setup Go
         uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4.1.0
         with:
-          go-version: ${{ needs.get-go-version.outputs.go-version }}
+          go-version: ${{ matrix.go-version }}
       - name: Check formatting
         run: "exit $(( $(gofmt -s -l . | wc -l) != 0 ))"
 
   test:
     name: codec test
     runs-on: ubuntu-latest
-    needs: [get-go-version]
+    strategy:
+      matrix:
+        go-version:
+          - "oldstable"
+          - "stable"
     steps:
       - name: Checkout Code
         uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0
       - name: Setup Go
         uses: actions/setup-go@93397bea11091df50f3d7e59dc26a7711a8bcfbe # v4.1.0
         with:
-          go-version: ${{ needs.get-go-version.outputs.go-version }}
+          go-version: ${{ matrix.go-version }}
       - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@4afd733a84b1f43292c63897423277bb7f4313a9 # v8.0.0
+        uses: golangci/golangci-lint-action@82606bf257cbaff209d206a39f5134f0cfbfd2ee # v9.2.1
         with:
-          version: v2.5.0
+          version: v2.12.2
       - run: go test -v ./codec
       - run: go test -tags codecgen.exec -v ./codec
       - name: Generate coverage report

.go-version

@@ -1 +1 @@
-1.24.7
+1.26.4

codec/codec_test.go

@@ -625,14 +625,14 @@ func testInit() {
 			"int32": int32(32323232),
 			"bool":  true,
 			"LONG STRING": `
-1234567890 1234567890 
-1234567890 1234567890 
-1234567890 1234567890 
-ABCDEDFGHIJKLMNOPQRSTUVWXYZ 
-abcdedfghijklmnopqrstuvwxyz 
-ABCDEDFGHIJKLMNOPQRSTUVWXYZ 
-abcdedfghijklmnopqrstuvwxyz 
-"ABCDEDFGHIJKLMNOPQRSTUVWXYZ" 
+1234567890 1234567890
+1234567890 1234567890
+1234567890 1234567890
+ABCDEDFGHIJKLMNOPQRSTUVWXYZ
+abcdedfghijklmnopqrstuvwxyz
+ABCDEDFGHIJKLMNOPQRSTUVWXYZ
+abcdedfghijklmnopqrstuvwxyz
+"ABCDEDFGHIJKLMNOPQRSTUVWXYZ"
 '	a tab	'
 \a\b\c\d\e
 \b\f\n\r\t all literally
@@ -899,7 +899,7 @@ func doTestCodecTableOne(t *testing.T, testNil bool, h Handle,
 		} else {
 			if v0 != nil {
 				v0rt := reflect.TypeOf(v0) // ptr
-				if v0rt.Kind() == reflect.Ptr {
+				if v0rt.Kind() == reflect.Pointer {
 					err = testUnmarshal(v0, b0, h)
 					v1 = v0
 				} else {
@@ -2095,7 +2095,7 @@ func testRandomFillRV(v reflect.Value) {
 
 	switch v.Kind() {
 	case reflect.Invalid:
-	case reflect.Ptr:
+	case reflect.Pointer:
 		if v.IsNil() {
 			v.Set(reflect.New(v.Type().Elem()))
 		}

codec/decode.go

@@ -1581,7 +1581,7 @@ func (d *Decoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 	rtelem0Mut := !isImmutableKind(rtElem0Kind)
 	rtelem := rtelem0
 	rtelemkind := rtelem.Kind()
-	for rtelemkind == reflect.Ptr {
+	for rtelemkind == reflect.Pointer {
 		rtelem = rtelem.Elem()
 		rtelemkind = rtelem.Kind()
 	}
@@ -1661,7 +1661,7 @@ func (d *Decoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 				rv.Send(reflect.Zero(rtelem0))
 				continue
 			}
-			if rtelem0Mut || !rv9.IsValid() { // || (rtElem0Kind == reflect.Ptr && rv9.IsNil()) {
+			if rtelem0Mut || !rv9.IsValid() { // || (rtElem0Kind == reflect.Pointer && rv9.IsNil()) {
 				rv9 = reflect.New(rtelem0).Elem()
 			}
 			if fn == nil {
@@ -1770,10 +1770,10 @@ func (d *Decoder) kMap(f *codecFnInfo, rv reflect.Value) {
 	var keyFn, valFn *codecFn
 	var ktypeLo, vtypeLo reflect.Type
 
-	for ktypeLo = ktype; ktypeLo.Kind() == reflect.Ptr; ktypeLo = ktypeLo.Elem() {
+	for ktypeLo = ktype; ktypeLo.Kind() == reflect.Pointer; ktypeLo = ktypeLo.Elem() {
 	}
 
-	for vtypeLo = vtype; vtypeLo.Kind() == reflect.Ptr; vtypeLo = vtypeLo.Elem() {
+	for vtypeLo = vtype; vtypeLo.Kind() == reflect.Pointer; vtypeLo = vtypeLo.Elem() {
 	}
 
 	var mapGet, mapSet bool
@@ -1783,7 +1783,7 @@ func (d *Decoder) kMap(f *codecFnInfo, rv reflect.Value) {
 		// if interface, mapGet = true if !DecodeNakedAlways (else false)
 		// if builtin, mapGet = false
 		// else mapGet = true
-		if vtypeKind == reflect.Ptr {
+		if vtypeKind == reflect.Pointer {
 			mapGet = true
 		} else if vtypeKind == reflect.Interface {
 			if !d.h.InterfaceReset {
@@ -1861,7 +1861,7 @@ func (d *Decoder) kMap(f *codecFnInfo, rv reflect.Value) {
 			rvv = rv.MapIndex(rvk)
 			if !rvv.IsValid() {
 				rvv = reflect.New(vtype).Elem()
-			} else if vtypeKind == reflect.Ptr {
+			} else if vtypeKind == reflect.Pointer {
 				if rvv.IsNil() {
 					rvv = reflect.New(vtype).Elem()
 				} else {
@@ -2775,15 +2775,15 @@ func (d *Decoder) decodeValue(rv reflect.Value, fn *codecFn, chkAll bool) {
 	// non-pointer value, and decode into that.
 	var rvp reflect.Value
 	var rvpValid bool
-	if rv.Kind() == reflect.Ptr {
+	if rv.Kind() == reflect.Pointer {
 		rvpValid = true
 		for {
 			if rv.IsNil() {
 				rv.Set(reflect.New(rv.Type().Elem()))
 			}
 			rvp = rv
 			rv = rv.Elem()
-			if rv.Kind() != reflect.Ptr {
+			if rv.Kind() != reflect.Pointer {
 				break
 			}
 		}
@@ -2833,7 +2833,7 @@ func isDecodeable(rv reflect.Value) (rv2 reflect.Value, canDecode bool) {
 	switch rv.Kind() {
 	case reflect.Array:
 		return rv, rv.CanAddr()
-	case reflect.Ptr:
+	case reflect.Pointer:
 		if !rv.IsNil() {
 			return rv.Elem(), true
 		}

codec/encode.go

@@ -607,7 +607,7 @@ func (e *Encoder) kSlice(f *codecFnInfo, rv reflect.Value) {
 
 	if l > 0 {
 		var fn *codecFn
-		for rtelem.Kind() == reflect.Ptr {
+		for rtelem.Kind() == reflect.Pointer {
 			rtelem = rtelem.Elem()
 		}
 		// if kind is reflect.Interface, do not pre-determine the
@@ -749,7 +749,7 @@ func (e *Encoder) kStruct(f *codecFnInfo, rv reflect.Value) {
 			// if a reference or struct, set to nil (so you do not output too much)
 			if si.omitEmpty() && isEmptyValue(kv.r, e.h.TypeInfos, recur, recur) {
 				switch kv.r.Kind() {
-				case reflect.Struct, reflect.Interface, reflect.Ptr,
+				case reflect.Struct, reflect.Interface, reflect.Pointer,
 					reflect.Array, reflect.Map, reflect.Slice:
 					kv.r = reflect.Value{} //encode as nil
 				}
@@ -848,7 +848,7 @@ func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
 	rtval0 := ti.elem
 	rtval := rtval0
 	// rtkeyid := rt2id(rtkey0)
-	for rtval.Kind() == reflect.Ptr {
+	for rtval.Kind() == reflect.Pointer {
 		rtval = rtval.Elem()
 	}
 	if rtval.Kind() != reflect.Interface {
@@ -864,7 +864,7 @@ func (e *Encoder) kMap(f *codecFnInfo, rv reflect.Value) {
 
 	var keyTypeIsString = stringTypId == rt2id(rtkey0) // rtkeyid
 	if !keyTypeIsString {
-		for rtkey.Kind() == reflect.Ptr {
+		for rtkey.Kind() == reflect.Pointer {
 			rtkey = rtkey.Elem()
 		}
 		if rtkey.Kind() != reflect.Interface {
@@ -1648,7 +1648,7 @@ func (e *Encoder) encodeValue(rv reflect.Value, fn *codecFn, checkFastpath bool)
 	var rvpValid bool
 TOP:
 	switch rv.Kind() {
-	case reflect.Ptr:
+	case reflect.Pointer:
 		if rv.IsNil() {
 			e.e.EncodeNil()
 			return

codec/helper.go

@@ -165,7 +165,7 @@ func init() {
 	pool.init()
 
 	refBitset.set(byte(reflect.Map))
-	refBitset.set(byte(reflect.Ptr))
+	refBitset.set(byte(reflect.Pointer))
 	refBitset.set(byte(reflect.Func))
 	refBitset.set(byte(reflect.Chan))
 }
@@ -434,7 +434,7 @@ var immutableKindsSet = [32]bool{
 	// reflect.Func: true,
 	// reflect.Interface
 	// reflect.Map
-	// reflect.Ptr
+	// reflect.Pointer
 	// reflect.Slice
 	reflect.String: true,
 	reflect.Struct: true,
@@ -740,7 +740,7 @@ func (x *BasicHandle) fn(rt reflect.Type, checkFastpath, checkCodecSelfer bool)
 					fi.addrF = false // meaning it can be an address(ptr) or a value
 					xfnf2 := fastpathAV[idx].decfn
 					fn.fd = func(d *Decoder, xf *codecFnInfo, xrv reflect.Value) {
-						if xrv.Kind() == reflect.Ptr {
+						if xrv.Kind() == reflect.Pointer {
 							xfnf2(d, xf, xrv.Convert(reflect.PointerTo(xrt)))
 						} else {
 							xfnf2(d, xf, xrv.Convert(xrt))
@@ -832,7 +832,7 @@ func (x *BasicHandle) fn(rt reflect.Type, checkFastpath, checkCodecSelfer bool)
 				fn.fd = (*Decoder).kInterface
 				fn.fe = (*Encoder).kErr
 			default:
-				// reflect.Ptr and reflect.Interface are handled already by preEncodeValue
+				// reflect.Pointer and reflect.Interface are handled already by preEncodeValue
 				fn.fe = (*Encoder).kErr
 				fn.fd = (*Decoder).kErr
 			}
@@ -1086,12 +1086,12 @@ func (o *extHandle) AddExt(rt reflect.Type, tag byte,
 func (o *extHandle) SetExt(rt reflect.Type, tag uint64, ext Ext) (err error) {
 	// o is a pointer, because we may need to initialize it
 	rk := rt.Kind()
-	for rk == reflect.Ptr {
+	for rk == reflect.Pointer {
 		rt = rt.Elem()
 		rk = rt.Kind()
 	}
 
-	if rt.PkgPath() == "" || rk == reflect.Interface { // || rk == reflect.Ptr {
+	if rt.PkgPath() == "" || rk == reflect.Interface { // || rk == reflect.Pointer {
 		return fmt.Errorf("codec.Handle.SetExt: Takes named type, not a pointer or interface: %v", rt)
 	}
 
@@ -1109,7 +1109,7 @@ func (o *extHandle) SetExt(rt reflect.Type, tag uint64, ext Ext) (err error) {
 			return
 		}
 	}
-	rtidptr := rt2id(reflect.PtrTo(rt))
+	rtidptr := rt2id(reflect.PointerTo(rt))
 	*o = append(o2, extTypeTagFn{rtid, rtidptr, rt, tag, ext, [1]uint64{}})
 	return
 }
@@ -1172,7 +1172,7 @@ func (o intf2impls) intf2impl(rtid uintptr) (rv reflect.Value) {
 			if v.impl == nil {
 				return
 			}
-			if v.impl.Kind() == reflect.Ptr {
+			if v.impl.Kind() == reflect.Pointer {
 				return reflect.New(v.impl.Elem())
 			}
 			return reflect.New(v.impl).Elem()
@@ -1387,7 +1387,7 @@ func (x *structFieldNode) field(si *structFieldInfo) (fv reflect.Value) {
 }
 
 func baseStructRv(v reflect.Value, update bool) (v2 reflect.Value, valid bool) {
-	for v.Kind() == reflect.Ptr {
+	for v.Kind() == reflect.Pointer {
 		if v.IsNil() {
 			if !update {
 				return
@@ -1568,7 +1568,7 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
 
 	rk := rt.Kind()
 
-	if rk == reflect.Ptr { // || (rk == reflect.Interface && rtid != intfTypId) {
+	if rk == reflect.Pointer { // || (rk == reflect.Interface && rtid != intfTypId) {
 		panicv.errorf("invalid kind passed to TypeInfos.get: %v - %v", rk, rt)
 	}
 
@@ -1633,7 +1633,7 @@ func (x *TypeInfos) get(rtid uintptr, rt reflect.Type) (pti *typeInfo) {
 	case reflect.Chan:
 		ti.elem = rt.Elem()
 		ti.chandir = uint8(rt.ChanDir())
-	case reflect.Array, reflect.Ptr:
+	case reflect.Array, reflect.Pointer:
 		ti.elem = rt.Elem()
 	}
 	// sfi = sfiSrc
@@ -1702,8 +1702,8 @@ LOOP:
 		if f.Anonymous && fkind != reflect.Interface {
 			// ^^ redundant but ok: per go spec, an embedded pointer type cannot be to an interface
 			ft := f.Type
-			isPtr := ft.Kind() == reflect.Ptr
-			for ft.Kind() == reflect.Ptr {
+			isPtr := ft.Kind() == reflect.Pointer
+			for ft.Kind() == reflect.Pointer {
 				ft = ft.Elem()
 			}
 			isStruct := ft.Kind() == reflect.Struct
@@ -2689,7 +2689,7 @@ func isEmptyValue(v reflect.Value, tinfos *TypeInfos, deref, checkStruct bool) b
 		return v.Uint() == 0
 	case reflect.Float32, reflect.Float64:
 		return v.Float() == 0
-	case reflect.Interface, reflect.Ptr:
+	case reflect.Interface, reflect.Pointer:
 		if deref {
 			if v.IsNil() {
 				return true

codec/internal/test_helper.go

@@ -25,7 +25,7 @@ func DeepEqual(v1, v2 interface{}) (err error) {
 func ApproxDataSize(rv reflect.Value) (sum int) {
 	switch rk := rv.Kind(); rk {
 	case reflect.Invalid:
-	case reflect.Ptr, reflect.Interface:
+	case reflect.Pointer, reflect.Interface:
 		sum += int(rv.Type().Size())
 		sum += ApproxDataSize(rv.Elem())
 	case reflect.Slice: