Update dependency golangci/golangci-lint to v2.13.2

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ on:
 
 env:
   # Common versions
-  GOLANGCI_VERSION: "v2.10.1"
+  GOLANGCI_VERSION: "v2.13.2"
   DOCKER_BUILDX_VERSION: "v0.37.0"
 
   # Common users. We can't run a step 'if secrets.AWS_USR != ""' but we can run

.golangci.yml

@@ -21,7 +21,6 @@ linters:
     - exhaustive
     - gocheckcompilerdirectives
     - gochecksumtype
-    - goconst
     - gocritic
     - gocyclo
     - gosec
@@ -151,10 +150,22 @@ linters:
           - staticcheck
         path: pkg/types/reference.go
         text: 'SA1019:'
+      - linters:
+          - staticcheck
+        path: pkg/types/reference_test.go
+        text: "SA1019: .*Type is deprecated in favor of TerraformName.*"
       - linters:
           - staticcheck
         path: pkg/types/markers/crossplane.go
         text: 'SA1019:'
+      - linters:
+          - staticcheck
+        path: pkg/types/markers/crossplane_test.go
+        text: "SA1019: .*Type is deprecated in favor of TerraformName.*"
+      - linters:
+          - staticcheck
+        path: pkg/types/comments/comment_test.go
+        text: "SA1019: .*Type is deprecated in favor of TerraformName.*"
       - linters:
           - govet
         text: 'buildtag:'

Makefile

@@ -12,7 +12,7 @@ GO_PROJECT := github.com/crossplane/$(PROJECT_NAME)/v2
 
 # GOLANGCILINT_VERSION is inherited from build submodule by default.
 # Uncomment below if you need to override the version.
-GOLANGCILINT_VERSION ?= 2.10.1
+GOLANGCILINT_VERSION ?= 2.13.2
 # GO_REQUIRED_VERSION ?= 1.22
 
 PLATFORMS ?= linux_amd64 linux_arm64

pkg/examples/conversion/example_conversions.go

@@ -48,7 +48,7 @@ func ApplyAPIConverters(pc *config.Provider, startPath, licenseHeaderPath string
 		var convertedFileContent string
 		if !info.IsDir() && strings.HasSuffix(info.Name(), ".yaml") {
 			log.Printf("Converting: %s\n", path)
-			content, err := os.ReadFile(filepath.Clean(path))
+			content, err := os.ReadFile(filepath.Clean(path)) //nolint:gosec // generation only
 			if err != nil {
 				return errors.Wrapf(err, "failed to read the %s file", path)
 			}

pkg/internal/ratelimiter/encapsulating_test.go

@@ -182,14 +182,14 @@ func TestEncapsulatingRateLimiterAdd(t *testing.T) {
 				rl1 := &fakeRateLimiter{name: "rl1"}
 				req1 := newReq("req-1")
 				return args{
-						op: addOp{key: "k1", rl: rl1, req: req1},
-					}, want{
-						state: state{
-							Inner:        map[reconcile.Request]string{req1: "k1"},
-							RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1},
-							Requests:     map[string]sets.Set[reconcile.Request]{"k1": sets.New[reconcile.Request](req1)},
-						},
-					}
+					op: addOp{key: "k1", rl: rl1, req: req1},
+				}, want{
+					state: state{
+						Inner:        map[reconcile.Request]string{req1: "k1"},
+						RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1},
+						Requests:     map[string]sets.Set[reconcile.Request]{"k1": sets.New[reconcile.Request](req1)},
+					},
+				}
 			},
 		},
 		"ExistingKeyNewRequest": {
@@ -200,15 +200,15 @@ func TestEncapsulatingRateLimiterAdd(t *testing.T) {
 				req1 := newReq("req-1")
 				req2 := newReq("req-2")
 				return args{
-						pre: []addOp{{key: "k1", rl: rl1, req: req1}},
-						op:  addOp{key: "k1", rl: rlIgnored, req: req2},
-					}, want{
-						state: state{
-							Inner:        map[reconcile.Request]string{req1: "k1", req2: "k1"},
-							RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1},
-							Requests:     map[string]sets.Set[reconcile.Request]{"k1": sets.New[reconcile.Request](req1, req2)},
-						},
-					}
+					pre: []addOp{{key: "k1", rl: rl1, req: req1}},
+					op:  addOp{key: "k1", rl: rlIgnored, req: req2},
+				}, want{
+					state: state{
+						Inner:        map[reconcile.Request]string{req1: "k1", req2: "k1"},
+						RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1},
+						Requests:     map[string]sets.Set[reconcile.Request]{"k1": sets.New[reconcile.Request](req1, req2)},
+					},
+				}
 			},
 		},
 		"ExistingKeySameRequest": {
@@ -218,15 +218,15 @@ func TestEncapsulatingRateLimiterAdd(t *testing.T) {
 				rlIgnored := &fakeRateLimiter{name: "rl-ignored"}
 				req1 := newReq("req-1")
 				return args{
-						pre: []addOp{{key: "k1", rl: rl1, req: req1}},
-						op:  addOp{key: "k1", rl: rlIgnored, req: req1},
-					}, want{
-						state: state{
-							Inner:        map[reconcile.Request]string{req1: "k1"},
-							RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1},
-							Requests:     map[string]sets.Set[reconcile.Request]{"k1": sets.New[reconcile.Request](req1)},
-						},
-					}
+					pre: []addOp{{key: "k1", rl: rl1, req: req1}},
+					op:  addOp{key: "k1", rl: rlIgnored, req: req1},
+				}, want{
+					state: state{
+						Inner:        map[reconcile.Request]string{req1: "k1"},
+						RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1},
+						Requests:     map[string]sets.Set[reconcile.Request]{"k1": sets.New[reconcile.Request](req1)},
+					},
+				}
 			},
 		},
 		"RequestMovesAndOldKeyDropped": {
@@ -236,18 +236,18 @@ func TestEncapsulatingRateLimiterAdd(t *testing.T) {
 				rl2 := &fakeRateLimiter{name: "rl2"}
 				req1 := newReq("req-1")
 				return args{
-						pre: []addOp{{key: "k1", rl: rl1, req: req1}},
-						op:  addOp{key: "k2", rl: rl2, req: req1},
-					}, want{
-						state: state{
-							Inner:        map[reconcile.Request]string{req1: "k2"},
-							RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k2": rl2},
-							Requests:     map[string]sets.Set[reconcile.Request]{"k2": sets.New[reconcile.Request](req1)},
-						},
-						forgetByRL: map[*fakeRateLimiter][]reconcile.Request{
-							rl1: {req1},
-						},
-					}
+					pre: []addOp{{key: "k1", rl: rl1, req: req1}},
+					op:  addOp{key: "k2", rl: rl2, req: req1},
+				}, want{
+					state: state{
+						Inner:        map[reconcile.Request]string{req1: "k2"},
+						RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k2": rl2},
+						Requests:     map[string]sets.Set[reconcile.Request]{"k2": sets.New[reconcile.Request](req1)},
+					},
+					forgetByRL: map[*fakeRateLimiter][]reconcile.Request{
+						rl1: {req1},
+					},
+				}
 			},
 		},
 		"RequestMovesButOldKeyRetained": {
@@ -258,24 +258,24 @@ func TestEncapsulatingRateLimiterAdd(t *testing.T) {
 				req1 := newReq("req-1")
 				req2 := newReq("req-2")
 				return args{
-						pre: []addOp{
-							{key: "k1", rl: rl1, req: req1},
-							{key: "k1", rl: rl1, req: req2},
-						},
-						op: addOp{key: "k2", rl: rl2, req: req1},
-					}, want{
-						state: state{
-							Inner:        map[reconcile.Request]string{req1: "k2", req2: "k1"},
-							RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1, "k2": rl2},
-							Requests: map[string]sets.Set[reconcile.Request]{
-								"k1": sets.New[reconcile.Request](req2),
-								"k2": sets.New[reconcile.Request](req1),
-							},
-						},
-						forgetByRL: map[*fakeRateLimiter][]reconcile.Request{
-							rl1: {req1},
+					pre: []addOp{
+						{key: "k1", rl: rl1, req: req1},
+						{key: "k1", rl: rl1, req: req2},
+					},
+					op: addOp{key: "k2", rl: rl2, req: req1},
+				}, want{
+					state: state{
+						Inner:        map[reconcile.Request]string{req1: "k2", req2: "k1"},
+						RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1, "k2": rl2},
+						Requests: map[string]sets.Set[reconcile.Request]{
+							"k1": sets.New[reconcile.Request](req2),
+							"k2": sets.New[reconcile.Request](req1),
 						},
-					}
+					},
+					forgetByRL: map[*fakeRateLimiter][]reconcile.Request{
+						rl1: {req1},
+					},
+				}
 			},
 		},
 	}
@@ -314,14 +314,14 @@ func TestEncapsulatingRateLimiterRemove(t *testing.T) {
 			reason: "Removing an unknown request must be a no-op: no state change and no Forget calls.",
 			setup: func() (args, want) {
 				return args{
-						req: newReq("req-1"),
-					}, want{
-						state: state{
-							Inner:        map[reconcile.Request]string{},
-							RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{},
-							Requests:     map[string]sets.Set[reconcile.Request]{},
-						},
-					}
+					req: newReq("req-1"),
+				}, want{
+					state: state{
+						Inner:        map[reconcile.Request]string{},
+						RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{},
+						Requests:     map[string]sets.Set[reconcile.Request]{},
+					},
+				}
 			},
 		},
 		"OnlyRequestForKey": {
@@ -330,18 +330,18 @@ func TestEncapsulatingRateLimiterRemove(t *testing.T) {
 				rl1 := &fakeRateLimiter{name: "rl1"}
 				req1 := newReq("req-1")
 				return args{
-						pre: []addOp{{key: "k1", rl: rl1, req: req1}},
-						req: req1,
-					}, want{
-						state: state{
-							Inner:        map[reconcile.Request]string{},
-							RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{},
-							Requests:     map[string]sets.Set[reconcile.Request]{},
-						},
-						forgetByRL: map[*fakeRateLimiter][]reconcile.Request{
-							rl1: {req1},
-						},
-					}
+					pre: []addOp{{key: "k1", rl: rl1, req: req1}},
+					req: req1,
+				}, want{
+					state: state{
+						Inner:        map[reconcile.Request]string{},
+						RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{},
+						Requests:     map[string]sets.Set[reconcile.Request]{},
+					},
+					forgetByRL: map[*fakeRateLimiter][]reconcile.Request{
+						rl1: {req1},
+					},
+				}
 			},
 		},
 		"OneOfMultipleRequests": {
@@ -351,21 +351,21 @@ func TestEncapsulatingRateLimiterRemove(t *testing.T) {
 				req1 := newReq("req-1")
 				req2 := newReq("req-2")
 				return args{
-						pre: []addOp{
-							{key: "k1", rl: rl1, req: req1},
-							{key: "k1", rl: rl1, req: req2},
-						},
-						req: req1,
-					}, want{
-						state: state{
-							Inner:        map[reconcile.Request]string{req2: "k1"},
-							RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1},
-							Requests:     map[string]sets.Set[reconcile.Request]{"k1": sets.New[reconcile.Request](req2)},
-						},
-						forgetByRL: map[*fakeRateLimiter][]reconcile.Request{
-							rl1: {req1},
-						},
-					}
+					pre: []addOp{
+						{key: "k1", rl: rl1, req: req1},
+						{key: "k1", rl: rl1, req: req2},
+					},
+					req: req1,
+				}, want{
+					state: state{
+						Inner:        map[reconcile.Request]string{req2: "k1"},
+						RateLimiters: map[string]workqueue.TypedRateLimiter[reconcile.Request]{"k1": rl1},
+						Requests:     map[string]sets.Set[reconcile.Request]{"k1": sets.New[reconcile.Request](req2)},
+					},
+					forgetByRL: map[*fakeRateLimiter][]reconcile.Request{
+						rl1: {req1},
+					},
+				}
 			},
 		},
 	}

pkg/pipeline/hooks_deprecated_version.go

@@ -113,7 +113,7 @@ func (mu *lifecycleMarkerUpdater) updateVersionFile(group, version string, resou
 	}
 
 	// Write back to file
-	if err := os.WriteFile(filePath, []byte(updatedContent), 0600); err != nil {
+	if err := os.WriteFile(filePath, []byte(updatedContent), 0600); err != nil { //nolint:gosec // generation only
 		return errors.Wrapf(err, "cannot write file %s", filePath)
 	}
 

pkg/pipeline/hooks_storage_version.go

@@ -114,7 +114,7 @@ func (svu *storageVersionMarkerUpdater) updateVersionFile(group, version string,
 	}
 
 	// Write back to file
-	if err := os.WriteFile(filePath, []byte(updatedContent), 0600); err != nil {
+	if err := os.WriteFile(filePath, []byte(updatedContent), 0600); err != nil { //nolint:gosec // generation only
 		return errors.Wrapf(err, "cannot write file %s", filePath)
 	}
 

pkg/registry/meta.go

@@ -511,7 +511,7 @@ func (pm *ProviderMetadata) ScrapeRepo(config *ScrapeConfiguration) error {
 		r := &Resource{}
 		// don't scrape if file is empty
 		filename := filepath.Clean(path)
-		b, err := os.ReadFile(filename)
+		b, err := os.ReadFile(filename) //nolint:gosec // generation only
 		if err != nil {
 			return errors.Wrap(err, "failed to read markdown file")
 		}

pkg/resource/lateinit.go

@@ -134,7 +134,7 @@ func zeroValueJSONOmitEmptyFilter(cName string) ValueFilter {
 			return true
 		case (k == reflect.Slice || k == reflect.Map) && v.Len() == 0:
 			return true
-		case k == reflect.Ptr && v.Elem().IsZero():
+		case k == reflect.Pointer && v.Elem().IsZero():
 			return true
 		default:
 			return false
@@ -159,7 +159,7 @@ func zeroElemPtrFilter(cName string) ValueFilter {
 		}
 
 		t := v.Type()
-		if t.Kind() != reflect.Ptr || v.IsNil() {
+		if t.Kind() != reflect.Pointer || v.IsNil() {
 			return false
 		}
 		if v.Elem().IsZero() {
@@ -220,10 +220,10 @@ func (li *GenericLateInitializer) LateInitialize(desiredObject, observedObject a
 	}
 
 	typeOfDesiredObject, typeOfObservedObject := reflect.TypeOf(desiredObject), reflect.TypeOf(observedObject)
-	if typeOfDesiredObject.Kind() != reflect.Ptr || typeOfDesiredObject.Elem().Kind() != reflect.Struct {
+	if typeOfDesiredObject.Kind() != reflect.Pointer || typeOfDesiredObject.Elem().Kind() != reflect.Struct {
 		return false, errors.Errorf(errFmtNotPtrToStruct, "desiredObject", desiredObject)
 	}
-	if typeOfObservedObject.Kind() != reflect.Ptr || typeOfObservedObject.Elem().Kind() != reflect.Struct {
+	if typeOfObservedObject.Kind() != reflect.Pointer || typeOfObservedObject.Elem().Kind() != reflect.Struct {
 		return false, errors.Errorf(errFmtNotPtrToStruct, "observedObject", observedObject)
 	}
 	if reflect.TypeOf(desiredObject) != reflect.TypeOf(observedObject) {
@@ -294,7 +294,7 @@ func (li *GenericLateInitializer) handleStruct(parentName string, desiredObject
 
 		switch desiredStructField.Type.Kind() { //nolint:exhaustive
 		// handle pointer struct field
-		case reflect.Ptr:
+		case reflect.Pointer:
 			desiredKeepField, err = li.handlePtr(cName, desiredFieldValue, observedFieldValue)
 
 		case reflect.Slice:
@@ -334,7 +334,7 @@ func (li *GenericLateInitializer) handlePtr(cName string, desiredFieldValue, obs
 		desiredKeepField = nestedFieldAssigned
 
 	default: // then cr object's field is not set but response object contains a value, carry it
-		if desiredFieldValue.Kind() == reflect.Ptr && desiredFieldValue.IsNil() {
+		if desiredFieldValue.Kind() == reflect.Pointer && desiredFieldValue.IsNil() {
 			desiredFieldValue.Set(reflect.New(desiredFieldValue.Type().Elem()))
 		}
 
@@ -364,7 +364,7 @@ func (li *GenericLateInitializer) handleSlice(cName string, desiredFieldValue, o
 		// check slice item's kind (not slice type)
 		switch item.Elem().Kind() { //nolint:exhaustive
 		// if dealing with a slice of pointers
-		case reflect.Ptr:
+		case reflect.Pointer:
 			_, err = li.handlePtr(cName, item.Elem(), observedFieldValue.Index(i))
 		case reflect.Struct:
 			_, err = li.handleStruct(cName, item.Interface(), observedFieldValue.Index(i).Addr().Interface())
@@ -407,7 +407,7 @@ func (li *GenericLateInitializer) handleMap(cName string, desiredFieldValue, obs
 		// check map item's kind (not map type)
 		switch item.Elem().Kind() { //nolint:exhaustive
 		// if dealing with a slice of pointers
-		case reflect.Ptr:
+		case reflect.Pointer:
 			_, err = li.handlePtr(cName, item.Elem(), observedFieldValue.MapIndex(k))
 		// else if dealing with a slice of slices
 		case reflect.Slice: