Apply new linting fixes

Author: mcbenjemaa

.golangci.yml

@@ -226,6 +226,9 @@ linters:
       - linters:
           - goconst
         path: (.+)_test\.go
+      - linters:
+          - staticcheck
+        text: 'QF1003: could use tagged switch on .*'
     paths:
       - zz_generated.*\.go$
       - vendored_openapi\.go$

internal/controllers/inclusterippool.go

@@ -131,7 +131,7 @@ func (r *InClusterIPPoolReconciler) Reconcile(ctx context.Context, req ctrl.Requ
 	log.Info("Reconciling pool")
 
 	pool := &v1alpha2.InClusterIPPool{}
-	if err := r.Client.Get(ctx, req.NamespacedName, pool); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, pool); err != nil {
 		if !apierrors.IsNotFound(err) {
 			return ctrl.Result{}, errors.Wrap(err, "failed to fetch InClusterIPPool")
 		}
@@ -151,7 +151,7 @@ func (r *GlobalInClusterIPPoolReconciler) Reconcile(ctx context.Context, req ctr
 	log.Info("Reconciling pool")
 
 	pool := &v1alpha2.GlobalInClusterIPPool{}
-	if err := r.Client.Get(ctx, req.NamespacedName, pool); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, pool); err != nil {
 		if !apierrors.IsNotFound(err) {
 			return ctrl.Result{}, errors.Wrap(err, "failed to fetch GlobalInClusterIPPool")
 		}

internal/controllers/ipaddressclaim.go

@@ -167,13 +167,13 @@ func (h *IPAddressClaimHandler) FetchPool(ctx context.Context) (client.Object, *
 
 	if h.claim.Spec.PoolRef.Kind == inClusterIPPoolKind {
 		icippool := &v1alpha2.InClusterIPPool{}
-		if err := h.Client.Get(ctx, types.NamespacedName{Namespace: h.claim.Namespace, Name: h.claim.Spec.PoolRef.Name}, icippool); err != nil {
+		if err := h.Get(ctx, types.NamespacedName{Namespace: h.claim.Namespace, Name: h.claim.Spec.PoolRef.Name}, icippool); err != nil {
 			return nil, nil, errors.Wrap(err, "failed to fetch pool")
 		}
 		h.pool = icippool
 	} else if h.claim.Spec.PoolRef.Kind == globalInClusterIPPoolKind {
 		gicippool := &v1alpha2.GlobalInClusterIPPool{}
-		if err := h.Client.Get(ctx, types.NamespacedName{Name: h.claim.Spec.PoolRef.Name}, gicippool); err != nil {
+		if err := h.Get(ctx, types.NamespacedName{Name: h.claim.Spec.PoolRef.Name}, gicippool); err != nil {
 			return nil, nil, err
 		}
 		h.pool = gicippool

internal/controllers/ipaddressclaim_test.go

@@ -1837,7 +1837,7 @@ var _ = Describe("IPAddressClaimReconciler", func() {
 				Eventually(Get(&cluster)).Should(Succeed())
 
 				claim := newClaim("test", namespace, "InClusterIPPool", poolName)
-				claim.ObjectMeta.Labels = map[string]string{
+				claim.Labels = map[string]string{
 					clusterv1.ClusterNameLabel: cluster.GetName(),
 				}
 				Expect(k8sClient.Create(context.Background(), &claim)).To(Succeed())
@@ -2000,7 +2000,7 @@ var _ = Describe("IPAddressClaimReconciler", func() {
 			})
 			It("does not allocate an ipaddress for the claim", func() {
 				claim := newClaim("test", namespace, "InClusterIPPool", poolName)
-				claim.ObjectMeta.Labels = map[string]string{
+				claim.Labels = map[string]string{
 					clusterv1.ClusterNameLabel: "an-unfindable-cluster",
 				}
 				Expect(k8sClient.Create(context.Background(), &claim)).To(Succeed())
@@ -2042,7 +2042,7 @@ var _ = Describe("IPAddressClaimReconciler", func() {
 
 		It("does not allocate an ipaddress for the claim until the ip address claim is unpaused", func() {
 			claim := newClaim("test", namespace, "InClusterIPPool", poolName)
-			claim.ObjectMeta.Annotations = map[string]string{
+			claim.Annotations = map[string]string{
 				clusterv1.PausedAnnotation: "",
 			}
 			Expect(k8sClient.Create(context.Background(), &claim)).To(Succeed())

pkg/ipamutil/reconciler.go

@@ -122,7 +122,7 @@ func (r *ClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ct
 
 	// Fetch the IPAddressClaim
 	claim := &ipamv1.IPAddressClaim{}
-	if err := r.Client.Get(ctx, req.NamespacedName, claim); err != nil {
+	if err := r.Get(ctx, req.NamespacedName, claim); err != nil {
 		if apierrors.IsNotFound(err) {
 			return ctrl.Result{}, nil
 		}
@@ -139,13 +139,13 @@ func (r *ClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ct
 	}
 	if err != nil {
 		if apierrors.IsNotFound(err) {
-			if !claim.ObjectMeta.DeletionTimestamp.IsZero() {
+			if !claim.DeletionTimestamp.IsZero() {
 				patch := client.MergeFrom(claim.DeepCopy())
 				if err := r.reconcileDelete(ctx, claim); err != nil {
 					return ctrl.Result{}, fmt.Errorf("reconcile delete: %w", err)
 				}
 				// we'll need to explicitly patch the claim here since we haven't set up a patch helper yet.
-				if err := r.Client.Patch(ctx, claim, patch); err != nil {
+				if err := r.Patch(ctx, claim, patch); err != nil {
 					return ctrl.Result{}, fmt.Errorf("patch after reconciling delete: %w", err)
 				}
 				return ctrl.Result{}, nil
@@ -187,7 +187,7 @@ func (r *ClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ct
 		if apierrors.IsNotFound(err) {
 			err := errors.New("pool not found")
 			log.Error(err, "the referenced pool could not be found")
-			if !claim.ObjectMeta.DeletionTimestamp.IsZero() {
+			if !claim.DeletionTimestamp.IsZero() {
 				return ctrl.Result{}, r.reconcileDelete(ctx, claim)
 			}
 			return ctrl.Result{}, nil
@@ -207,7 +207,7 @@ func (r *ClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ct
 	}
 
 	// If the claim is marked for deletion, release the address.
-	if !claim.ObjectMeta.DeletionTimestamp.IsZero() {
+	if !claim.DeletionTimestamp.IsZero() {
 		if res, err := handler.ReleaseAddress(ctx); err != nil {
 			return unwrapResult(res), err
 		}
@@ -267,21 +267,21 @@ func (r *ClaimReconciler) reconcileDelete(ctx context.Context, claim *ipamv1.IPA
 		Namespace: claim.Namespace,
 		Name:      claim.Name,
 	}
-	if err := r.Client.Get(ctx, namespacedName, address); err != nil && !apierrors.IsNotFound(err) {
+	if err := r.Get(ctx, namespacedName, address); err != nil && !apierrors.IsNotFound(err) {
 		return errors.Wrap(err, "failed to fetch address")
 	}
 
 	if address.Name != "" {
 		var err error
 		patch := client.MergeFrom(address.DeepCopy())
 		if controllerutil.RemoveFinalizer(address, ProtectAddressFinalizer) {
-			if err = r.Client.Patch(ctx, address, patch); err != nil && !apierrors.IsNotFound(err) {
+			if err = r.Patch(ctx, address, patch); err != nil && !apierrors.IsNotFound(err) {
 				return errors.Wrap(err, "failed to remove address finalizer")
 			}
 		}
 
 		if err == nil {
-			if err := r.Client.Delete(ctx, address); err != nil && !apierrors.IsNotFound(err) {
+			if err := r.Delete(ctx, address); err != nil && !apierrors.IsNotFound(err) {
 				return err
 			}
 		}
@@ -294,7 +294,7 @@ func (r *ClaimReconciler) reconcileDelete(ctx context.Context, claim *ipamv1.IPA
 func (r *ClaimReconciler) clusterToIPClaims(_ context.Context, a client.Object) []reconcile.Request {
 	requests := []reconcile.Request{}
 	claims := &ipamv1.IPAddressClaimList{}
-	if err := r.Client.List(context.Background(), claims, client.MatchingFields{"clusterName": a.GetName()}); err != nil {
+	if err := r.List(context.Background(), claims, client.MatchingFields{"clusterName": a.GetName()}); err != nil {
 		return requests
 	}
 	for _, c := range claims.Items {