chore: enable all staticcheck linter checks (#405)

Signed-off-by: Sahid Velji <[email protected]>

Author: sahidvelji

.golangci.yml

@@ -16,6 +16,10 @@ linters:
     - unused
     - misspell
     - dupword
+  settings:
+    staticcheck:
+      checks:
+        - "all"
 
 issues:
   max-issues-per-linter: 0

openfeature/client.go

@@ -700,7 +700,7 @@ func (c *Client) evaluate(
 
 	evalCtx = mergeContexts(evalCtx, c.evaluationContext, TransactionContext(ctx), globalEvalCtx)            // API (global) -> transaction -> client -> invocation
 	apiClientInvocationProviderHooks := slices.Concat(globalHooks, c.hooks, options.hooks, provider.Hooks()) // API, Client, Invocation, Provider
-	providerInvocationClientApiHooks := slices.Concat(provider.Hooks(), options.hooks, c.hooks, globalHooks) // Provider, Invocation, Client, API
+	providerInvocationClientAPIHooks := slices.Concat(provider.Hooks(), options.hooks, c.hooks, globalHooks) // Provider, Invocation, Client, API
 
 	var err error
 	hookCtx := HookContext{
@@ -713,20 +713,20 @@ func (c *Client) evaluate(
 	}
 
 	defer func() {
-		c.finallyHooks(ctx, hookCtx, providerInvocationClientApiHooks, evalDetails, options)
+		c.finallyHooks(ctx, hookCtx, providerInvocationClientAPIHooks, evalDetails, options)
 	}()
 
 	// bypass short-circuit logic for the Noop provider; it is essentially stateless and a "special case"
 	if _, ok := provider.(NoopProvider); !ok {
 		// short circuit if provider is in NOT READY state
 		if c.State() == NotReadyState {
-			c.errorHooks(ctx, hookCtx, providerInvocationClientApiHooks, ProviderNotReadyError, options)
+			c.errorHooks(ctx, hookCtx, providerInvocationClientAPIHooks, ProviderNotReadyError, options)
 			return evalDetails, ProviderNotReadyError
 		}
 
 		// short circuit if provider is in FATAL state
 		if c.State() == FatalState {
-			c.errorHooks(ctx, hookCtx, providerInvocationClientApiHooks, ProviderFatalError, options)
+			c.errorHooks(ctx, hookCtx, providerInvocationClientAPIHooks, ProviderFatalError, options)
 			return evalDetails, ProviderFatalError
 		}
 	}
@@ -735,7 +735,7 @@ func (c *Client) evaluate(
 	hookCtx.evaluationContext = evalCtx
 	if err != nil {
 		err = fmt.Errorf("before hook: %w", err)
-		c.errorHooks(ctx, hookCtx, providerInvocationClientApiHooks, err, options)
+		c.errorHooks(ctx, hookCtx, providerInvocationClientAPIHooks, err, options)
 		return evalDetails, err
 	}
 
@@ -769,17 +769,17 @@ func (c *Client) evaluate(
 	err = resolution.Error()
 	if err != nil {
 		err = fmt.Errorf("error code: %w", err)
-		c.errorHooks(ctx, hookCtx, providerInvocationClientApiHooks, err, options)
+		c.errorHooks(ctx, hookCtx, providerInvocationClientAPIHooks, err, options)
 		evalDetails.ResolutionDetail = resolution.ResolutionDetail()
 		evalDetails.Reason = ErrorReason
 		return evalDetails, err
 	}
 	evalDetails.Value = resolution.Value
 	evalDetails.ResolutionDetail = resolution.ResolutionDetail()
 
-	if err := c.afterHooks(ctx, hookCtx, providerInvocationClientApiHooks, evalDetails, options); err != nil {
+	if err := c.afterHooks(ctx, hookCtx, providerInvocationClientAPIHooks, evalDetails, options); err != nil {
 		err = fmt.Errorf("after hook: %w", err)
-		c.errorHooks(ctx, hookCtx, providerInvocationClientApiHooks, err, options)
+		c.errorHooks(ctx, hookCtx, providerInvocationClientAPIHooks, err, options)
 		return evalDetails, err
 	}
 

openfeature/client_test.go

@@ -19,21 +19,21 @@ type clientMocks struct {
 
 func hydratedMocksForClientTests(t *testing.T, expectedEvaluations int) clientMocks {
 	ctrl := gomock.NewController(t)
-	mockClientApi := NewMockclientEvent(ctrl)
-	mockEvaluationApi := NewMockevaluationImpl(ctrl)
+	mockClientAPI := NewMockclientEvent(ctrl)
+	mockEvaluationAPI := NewMockevaluationImpl(ctrl)
 	mockProvider := NewMockFeatureProvider(ctrl)
 
-	mockClientApi.EXPECT().State(gomock.Any()).AnyTimes().Return(ReadyState)
+	mockClientAPI.EXPECT().State(gomock.Any()).AnyTimes().Return(ReadyState)
 
 	mockProvider.EXPECT().Metadata().AnyTimes()
 	mockProvider.EXPECT().Hooks().AnyTimes()
-	mockEvaluationApi.EXPECT().ForEvaluation(gomock.Any()).Times(expectedEvaluations).DoAndReturn(func(_ string) (*MockFeatureProvider, []Hook, EvaluationContext) {
+	mockEvaluationAPI.EXPECT().ForEvaluation(gomock.Any()).Times(expectedEvaluations).DoAndReturn(func(_ string) (*MockFeatureProvider, []Hook, EvaluationContext) {
 		return mockProvider, nil, EvaluationContext{}
 	})
 
 	return clientMocks{
-		clientHandlerAPI: mockClientApi,
-		evaluationAPI:    mockEvaluationApi,
+		clientHandlerAPI: mockClientAPI,
+		evaluationAPI:    mockEvaluationAPI,
 		providerAPI:      mockProvider,
 	}
 }

openfeature/evaluation_context.go

@@ -60,7 +60,7 @@ func NewTargetlessEvaluationContext(attributes map[string]any) EvaluationContext
 	return NewEvaluationContext("", attributes)
 }
 
-// NewTransactionContext constructs a TransactionContext
+// WithTransactionContext constructs a TransactionContext.
 //
 // ctx - the context to embed the EvaluationContext in
 // ec - the EvaluationContext to embed into the context

openfeature/hooks/doc.go

@@ -0,0 +1,2 @@
+// Package hooks provides OpenFeature hooks.
+package hooks

openfeature/internal/context_key.go

@@ -1,3 +1,4 @@
+// Package internal contains internal identifiers for the OpenFeature SDK.
 package internal
 
 // ContextKey is just an empty struct. It exists so TransactionContext can be

openfeature/memprovider/in_memory_provider.go

@@ -1,3 +1,4 @@
+// Package memprovider provides an in-memory feature flag provider for OpenFeature.
 package memprovider
 
 import (

openfeature/openfeature.go

@@ -22,6 +22,8 @@ func initSingleton() {
 
 // GetApiInstance returns the current singleton IEvaluation instance.
 // This is the preferred interface to interact with OpenFeature functionalities
+//
+//nolint:staticcheck // Renaming this now would be a breaking change.
 func GetApiInstance() IEvaluation {
 	return api
 }

openfeature/testing/testprovider.go

@@ -1,3 +1,4 @@
+// Package testing provides a test-aware feature flag provider for OpenFeature.
 package testing
 
 import (
@@ -27,9 +28,9 @@ type TestProvider struct {
 	providers *sync.Map
 }
 
-// UsingFlags sets flags for the scope of a test
 type TestFramework = interface{ Name() string }
 
+// UsingFlags sets flags for the scope of a test.
 func (tp TestProvider) UsingFlags(test TestFramework, flags map[string]memprovider.InMemoryFlag) {
 	storeGoroutineLocal(test.Name())
 	tp.providers.Store(test.Name(), memprovider.NewInMemoryProvider(flags))

pkg/openfeature/client.go

@@ -1,3 +1,4 @@
+//nolint:staticcheck
 package openfeature
 
 import (