Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

benchmark: PR 4871 (iface) #14

Open
ldez opened this issue Jul 18, 2024 · 2 comments
Open

benchmark: PR 4871 (iface) #14

ldez opened this issue Jul 18, 2024 · 2 comments
Labels
bench-new-linter

Comments

@ldez
Copy link
Owner

ldez commented Jul 18, 2024

{
"pr": 4871,
"linter": "iface"
}
@github-actions GitHub Actions

This comment was marked as outdated.

Sign in to view
@ldez ldez mentioned this issue Jul 18, 2024
Open
@github-actions GitHub Actions
Copy link

The benchmark (Benchmark PR (new linter)) is done!

beego/beego

client/orm/types.go:116:6: identical: interface TxCommitter contains identical methods or type constraints from another interface, causing redundancy (iface)
type TxCommitter interface {
     ^
client/orm/types.go:247:6: identical: interface ormer contains identical methods or type constraints from another interface, causing redundancy (iface)
type ormer interface {
     ^
client/orm/types.go:254:6: identical: interface QueryExecutor contains identical methods or type constraints from another interface, causing redundancy (iface)
type QueryExecutor interface {
     ^
client/orm/types.go:127:6: identical: interface txEnder contains identical methods or type constraints from another interface, causing redundancy (iface)
type txEnder interface {
     ^
client/orm/internal/buffers/buffers.go:28:12: opaque: Get function return Buffer interface at the 1st result, abstract a single concrete implementation of *github.com/valyala/bytebufferpool.ByteBuffer (iface)
func Get() Buffer {
           ^
client/cache/file.go:61:21: opaque: NewFileCache function return Cache interface at the 1st result, abstract a single concrete implementation of *FileCache (iface)
func NewFileCache() Cache {
                    ^
client/cache/memory.go:56:23: opaque: NewMemoryCache function return Cache interface at the 1st result, abstract a single concrete implementation of *MemoryCache (iface)
func NewMemoryCache() Cache {
                      ^
client/cache/random_expired_cache.go:48:75: opaque: NewRandomExpireCache function return Cache interface at the 1st result, abstract a single concrete implementation of *RandomExpireCache (iface)
func NewRandomExpireCache(adapter Cache, opts ...RandomExpireCacheOption) Cache {
                                                                          ^
client/httplib/mock/mock.go:43:18: opaque: StartMock function return Stub interface at the 1st result, abstract a single concrete implementation of *MockResponseFilter (iface)
func StartMock() Stub {
                 ^
client/orm/db_mysql.go:180:23: opaque: newdbBaseMysql function return dbBaser interface at the 1st result, abstract a single concrete implementation of *dbBaseMysql (iface)
func newdbBaseMysql() dbBaser {
                      ^
client/orm/db_oracle.go:67:24: opaque: newdbBaseOracle function return dbBaser interface at the 1st result, abstract a single concrete implementation of *dbBaseOracle (iface)
func newdbBaseOracle() dbBaser {
                       ^
client/orm/db_postgres.go:195:26: opaque: newdbBasePostgres function return dbBaser interface at the 1st result, abstract a single concrete implementation of *dbBasePostgres (iface)
func newdbBasePostgres() dbBaser {
                         ^
client/orm/db_sqlite.go:182:24: opaque: newdbBaseSqlite function return dbBaser interface at the 1st result, abstract a single concrete implementation of *dbBaseSqlite (iface)
func newdbBaseSqlite() dbBaser {
                       ^
client/orm/db_tidb.go:60:22: opaque: newdbBaseTidb function return dbBaser interface at the 1st result, abstract a single concrete implementation of *dbBaseTidb (iface)
func newdbBaseTidb() dbBaser {
                     ^
client/orm/filter_orm_decorator.go:52:73: opaque: NewFilterOrmDecorator function return Ormer interface at the 1st result, abstract a single concrete implementation of *filterOrmDecorator (iface)
func NewFilterOrmDecorator(delegate Ormer, filterChains ...FilterChain) Ormer {
                                                                        ^
client/orm/filter_orm_decorator.go:68:76: opaque: NewFilterTxOrmDecorator function return TxOrmer interface at the 1st result, abstract a single concrete implementation of *filterOrmDecorator (iface)
func NewFilterTxOrmDecorator(delegate TxOrmer, root Filter, txName string) TxOrmer {
                                                                           ^
client/orm/orm_log.go:122:68: opaque: newStmtQueryLog function return stmtQuerier interface at the 1st result, abstract a single concrete implementation of *stmtQueryLog (iface)
func newStmtQueryLog(alias *alias, stmt stmtQuerier, query string) stmtQuerier {
                                                                   ^
client/orm/orm_log.go:225:48: opaque: newDbQueryLog function return dbQuerier interface at the 1st result, abstract a single concrete implementation of *dbQueryLog (iface)
func newDbQueryLog(alias *alias, db dbQuerier) dbQuerier {
                                               ^
client/orm/orm_querym2m.go:158:109: opaque: newQueryM2M function return QueryM2Mer interface at the 1st result, abstract a single concrete implementation of *queryM2M (iface)
func newQueryM2M(md interface{}, o *ormBase, mi *models.ModelInfo, fi *models.FieldInfo, ind reflect.Value) QueryM2Mer {
                                                                                                            ^
client/orm/orm_queryset.go:377:54: opaque: newQuerySet function return QuerySeter interface at the 1st result, abstract a single concrete implementation of *querySet (iface)
func newQuerySet(orm *ormBase, mi *models.ModelInfo) QuerySeter {
                                                     ^
client/orm/orm_raw.go:916:64: opaque: newRawSet function return RawSeter interface at the 1st result, abstract a single concrete implementation of *rawSet (iface)
func newRawSet(orm *ormBase, query string, args []interface{}) RawSeter {
                                                               ^
client/orm/mock/condition.go:46:62: opaque: NewSimpleCondition function return Condition interface at the 1st result, abstract a single concrete implementation of *SimpleCondition (iface)
func NewSimpleCondition(tableName string, methodName string) Condition {
                                                             ^
client/orm/mock/mock.go:38:18: opaque: StartMock function return Stub interface at the 1st result, abstract a single concrete implementation of *OrmStub (iface)
func StartMock() Stub {
                 ^
core/berror/codes.go:37:71: opaque: DefineCode function return Code interface at the 1st result, abstract a single concrete implementation of *codeDefinition (iface)
func DefineCode(code uint32, module string, name string, desc string) Code {
                                                                      ^
core/config/fake.go:108:22: opaque: NewFakeConfig function return Configer interface at the 1st result, abstract a single concrete implementation of *fakeConfigContainer (iface)
func NewFakeConfig() Configer {
                     ^
core/logs/conn.go:39:16: opaque: NewConn function return Logger interface at the 1st result, abstract a single concrete implementation of *connWriter (iface)
func NewConn() Logger {
               ^
core/logs/console.go:72:19: opaque: NewConsole function return Logger interface at the 1st result, abstract a single concrete implementation of *consoleWriter (iface)
func NewConsole() Logger {
                  ^
core/logs/file.go:80:22: opaque: newFileWriter function return Logger interface at the 1st result, abstract a single concrete implementation of *fileLogWriter (iface)
func newFileWriter() Logger {
                     ^
core/logs/jianliao.go:24:20: opaque: newJLWriter function return Logger interface at the 1st result, abstract a single concrete implementation of *JLWriter (iface)
func newJLWriter() Logger {
                   ^
core/logs/multifile.go:125:23: opaque: newFilesWriter function return Logger interface at the 1st result, abstract a single concrete implementation of *multiFileLogWriter (iface)
func newFilesWriter() Logger {
                      ^
core/logs/slack.go:19:23: opaque: newSLACKWriter function return Logger interface at the 1st result, abstract a single concrete implementation of *SLACKWriter (iface)
func newSLACKWriter() Logger {
                      ^
core/logs/smtp.go:43:22: opaque: newSMTPWriter function return Logger interface at the 1st result, abstract a single concrete implementation of *SMTPWriter (iface)
func newSMTPWriter() Logger {
                     ^
core/logs/log_test.go:44:22: opaque: NewMockLogger function return Logger interface at the 1st result, abstract a single concrete implementation of *mockLogger (iface)
func NewMockLogger() Logger {
                     ^
core/utils/kv.go:79:24: opaque: NewKVs function return KVs interface at the 1st result, abstract a single concrete implementation of *SimpleKVs (iface)
func NewKVs(kvs ...KV) KVs {
                       ^
server/web/filter/ratelimit/token_bucket.go:17:43: opaque: newTokenBucket function return bucket interface at the 1st result, abstract a single concrete implementation of *tokenBucket (iface)
func newTokenBucket(opts ...bucketOption) bucket {
                                          ^
client/orm/types.go:70:6: unused: interface TableIndexI is declared but not used within the package (iface)
type TableIndexI interface {
     ^
client/orm/types.go:85:6: unused: interface TableUniqueI is declared but not used within the package (iface)
type TableUniqueI interface {
     ^
client/orm/types.go:55:6: unused: interface TableEngineI is declared but not used within the package (iface)
type TableEngineI interface {
     ^
client/orm/types.go:40:6: unused: interface TableNameI is declared but not used within the package (iface)
type TableNameI interface {
     ^
core/bean/factory.go:22:6: unused: interface AutoWireBeanFactory is declared but not used within the package (iface)
type AutoWireBeanFactory interface {
     ^
Command Mean [ms] Min [ms] Max [ms] Relative
iface 862.4 ± 14.4 844.6 883.7 1.67 ± 0.03
goconst 515.5 ± 5.6 507.2 524.5 1.00
durationcheck 844.9 ± 13.1 827.0 864.8 1.64 ± 0.03

cilium/cilium

cilium-cli/connectivity/filters/filters.go:84:47: opaque: And function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *andFilter (iface)
func And(filters ...FlowFilterImplementation) FlowFilterImplementation {
                                              ^
cilium-cli/connectivity/filters/filters.go:112:46: opaque: Or function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *orFilter (iface)
func Or(filters ...FlowFilterImplementation) FlowFilterImplementation {
                                             ^
cilium-cli/connectivity/filters/filters.go:161:27: opaque: Drop function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *dropFilter (iface)
func Drop(opts ...Option) FlowFilterImplementation {
                          ^
cilium-cli/connectivity/filters/filters.go:188:15: opaque: L7Drop function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *l7DropFilter (iface)
func L7Drop() FlowFilterImplementation {
              ^
cilium-cli/connectivity/filters/filters.go:219:23: opaque: ICMP function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *icmpFilter (iface)
func ICMP(typ uint32) FlowFilterImplementation {
                      ^
cilium-cli/connectivity/filters/filters.go:250:25: opaque: ICMPv6 function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *icmpv6Filter (iface)
func ICMPv6(typ uint32) FlowFilterImplementation {
                        ^
cilium-cli/connectivity/filters/filters.go:309:32: opaque: UDP function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *udpFilter (iface)
func UDP(srcPort, dstPort int) FlowFilterImplementation {
                               ^
cilium-cli/connectivity/filters/filters.go:353:40: opaque: TCPFlags function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *tcpFlagsFilter (iface)
func TCPFlags(syn, ack, fin, rst bool) FlowFilterImplementation {
                                       ^
cilium-cli/connectivity/filters/filters.go:418:30: opaque: IP function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *ipFilter (iface)
func IP(srcIP, dstIP string) FlowFilterImplementation {
                             ^
cilium-cli/connectivity/filters/filters.go:481:35: opaque: TCP function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *tcpFilter (iface)
func TCP(srcPort, dstPort uint32) FlowFilterImplementation {
                                  ^
cilium-cli/connectivity/filters/filters.go:524:38: opaque: DNS function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *dnsFilter (iface)
func DNS(query string, rcode uint32) FlowFilterImplementation {
                                     ^
cilium-cli/connectivity/filters/filters.go:602:44: opaque: HTTP function return FlowFilterImplementation interface at the 1st result, abstract a single concrete implementation of *httpFilter (iface)
func HTTP(code uint32, method, url string) FlowFilterImplementation {
                                           ^
pkg/k8s/slim/k8s/apis/labels/selector.go:96:20: opaque: NewSelector function return Selector interface at the 1st result, abstract a single concrete implementation of internalSelector (iface)
func NewSelector() Selector {
                   ^
pkg/k8s/slim/k8s/apis/labels/selector.go:932:39: opaque: SelectorFromValidatedSet function return Selector interface at the 1st result, abstract a single concrete implementation of internalSelector (iface)
func SelectorFromValidatedSet(ls Set) Selector {
                                      ^
pkg/k8s/resource/resource.go:139:98: opaque: New function return Resource[T] interface at the 1st result, abstract a single concrete implementation of *resource[T] (iface)
func New[T k8sRuntime.Object](lc cell.Lifecycle, lw cache.ListerWatcher, opts ...ResourceOption) Resource[T] {
                                                                                                 ^
pkg/crypto/certificatemanager/certificate_manager.go:59:68: opaque: NewManager function return CertificateManager interface at the 1st result, abstract a single concrete implementation of *manager (iface)
func NewManager(cfg managerConfig, clientset k8sClient.Clientset) (CertificateManager, SecretManager) {
                                                                   ^
pkg/bgpv1/types/fake_router.go:10:22: opaque: NewFakeRouter function return Router interface at the 1st result, abstract a single concrete implementation of *FakeRouter (iface)
func NewFakeRouter() Router {
                     ^
pkg/maps/l2respondermap/l2_responder_map4.go:33:40: opaque: NewMap function return Map interface at the 1st result, abstract a single concrete implementation of *l2ResponderMap (iface)
func NewMap(lifecycle cell.Lifecycle) (Map, error) {
                                       ^
pkg/maps/l2respondermap/l2_responder_map4_fake.go:10:19: opaque: NewFakeMap function return Map interface at the 1st result, abstract a single concrete implementation of *fakeMap (iface)
func NewFakeMap() Map {
                  ^
pkg/maps/ctmap/gc/gc.go:343:16: opaque: NewFake function return Enabler interface at the 1st result, abstract a single concrete implementation of fakeCTMapGC (iface)
func NewFake() Enabler { return fakeCTMapGC{} }
               ^
plugins/cilium-docker/driver/driver.go:81:56: opaque: NewDriver function return Driver interface at the 1st result, abstract a single concrete implementation of *driver (iface)
func NewDriver(ciliumSockPath, dockerHostPath string) (Driver, error) {
                                                       ^
cilium-cli/connectivity/check/peer.go:355:38: opaque: ICMPEndpoint function return TestPeer interface at the 1st result, abstract a single concrete implementation of icmpEndpoint (iface)
func ICMPEndpoint(name, host string) TestPeer {
                                     ^
cilium-cli/connectivity/check/peer.go:417:76: opaque: HTTPEndpointWithLabels function return TestPeer interface at the 1st result, abstract a single concrete implementation of httpEndpoint (iface)
func HTTPEndpointWithLabels(name, rawurl string, labels map[string]string) TestPeer {
                                                                           ^
clustermesh-apiserver/clustermesh/root.go:115:172: opaque: newIdentitySynchronizer function return synchronizer interface at the 1st result, abstract a single concrete implementation of *identitySynchronizer (iface)
func newIdentitySynchronizer(ctx context.Context, cinfo cmtypes.ClusterInfo, backend kvstore.BackendOperations, factory store.Factory, syncCallback func(context.Context)) synchronizer {
                                                                                                                                                                           ^
clustermesh-apiserver/clustermesh/root.go:191:168: opaque: newNodeSynchronizer function return synchronizer interface at the 1st result, abstract a single concrete implementation of *nodeSynchronizer (iface)
func newNodeSynchronizer(ctx context.Context, cinfo cmtypes.ClusterInfo, backend kvstore.BackendOperations, factory store.Factory, syncCallback func(context.Context)) synchronizer {
                                                                                                                                                                       ^
clustermesh-apiserver/clustermesh/root.go:244:172: opaque: newEndpointSynchronizer function return synchronizer interface at the 1st result, abstract a single concrete implementation of *endpointSynchronizer (iface)
func newEndpointSynchronizer(ctx context.Context, cinfo cmtypes.ClusterInfo, backend kvstore.BackendOperations, factory store.Factory, syncCallback func(context.Context)) synchronizer {
                                                                                                                                                                           ^
daemon/cmd/cni/cell.go:78:128: opaque: enableConfigManager function return CNIConfigManager interface at the 1st result, abstract a single concrete implementation of *cniConfigManager (iface)
func enableConfigManager(lc cell.Lifecycle, log logrus.FieldLogger, cfg Config, dcfg *option.DaemonConfig /*only for .Debug*/) CNIConfigManager {
                                                                                                                               ^
operator/api/server.go:73:4: opaque: newServer function return Server interface at the 1st result, abstract a single concrete implementation of *server (iface)
) (Server, error) {
   ^
operator/pkg/ciliumendpointslice/manager.go:68:69: opaque: newCESManagerFcfs function return operations interface at the 1st result, abstract a single concrete implementation of *cesManagerFcfs (iface)
func newCESManagerFcfs(maxCEPsInCES int, logger logrus.FieldLogger) operations {
                                                                    ^
operator/pkg/ciliumendpointslice/manager.go:79:73: opaque: newCESManagerIdentity function return operations interface at the 1st result, abstract a single concrete implementation of *cesManagerIdentity (iface)
func newCESManagerIdentity(maxCEPsInCES int, logger logrus.FieldLogger) operations {
                                                                        ^
operator/pkg/model/translation/cec_translator.go:67:3: opaque: NewCECTranslator function return CECTranslator interface at the 1st result, abstract a single concrete implementation of *cecTranslator (iface)
) CECTranslator {
  ^
pkg/backoff/backoff.go:36:98: opaque: NewNodeManager function return NodeManager interface at the 1st result, abstract a single concrete implementation of *nodeManager (iface)
func NewNodeManager(clusterSizeDependantInterval func(baseInterval time.Duration) time.Duration) NodeManager {
                                                                                                 ^
pkg/bgpv1/manager/store/resource_store_mock.go:59:51: opaque: InitMockStore function return BGPCPResourceStore[T] interface at the 1st result, abstract a single concrete implementation of *mockBGPCPResourceStore[T] (iface)
func InitMockStore[T runtime.Object](objects []T) BGPCPResourceStore[T] {
                                                  ^
pkg/cgroups/manager/manager_test.go:124:100: opaque: newCgroupManagerTest function return CGroupManager interface at the 1st result, abstract a single concrete implementation of *cgroupManager (iface)
func newCgroupManagerTest(t testing.TB, pMock providerMock, cg cgroup, events chan podEventStatus) CGroupManager {
                                                                                                   ^
pkg/ciliumenvoyconfig/cell.go:143:42: opaque: newCECManager function return ciliumEnvoyConfigManager interface at the 1st result, abstract a single concrete implementation of *cecManager (iface)
func newCECManager(params managerParams) ciliumEnvoyConfigManager {
                                         ^
pkg/clustermesh/common/clustermesh.go:85:38: opaque: NewClusterMesh function return ClusterMesh interface at the 1st result, abstract a single concrete implementation of *clusterMesh (iface)
func NewClusterMesh(c Configuration) ClusterMesh {
                                     ^
pkg/container/bitlpm/trie.go:112:40: opaque: NewTrie function return Key[K], T] interface at the 1st result, abstract a single concrete implementation of *trie[K, T] (iface)
func NewTrie[K, T any](maxPrefix uint) Trie[Key[K], T] {
                                       ^
pkg/datapath/iptables/ipset/ipset.go:151:3: opaque: newIPSetManager function return Manager interface at the 1st result, abstract a single concrete implementation of *manager (iface)
) Manager {
  ^
pkg/datapath/l2responder/l2responder.go:63:27: opaque: newNeighborNetlink function return linkByNamer interface at the 1st result, abstract a single concrete implementation of *github.com/vishvananda/netlink.Handle (iface)
func newNeighborNetlink() linkByNamer {
                          ^
pkg/datapath/linux/sysctl/sysctl.go:80:3: opaque: newReconcilingSysctl function return Sysctl interface at the 1st result, abstract a single concrete implementation of *reconcilingSysctl (iface)
) Sysctl {
  ^
pkg/datapath/linux/sysctl/sysctl.go:183:50: opaque: NewDirectSysctl function return Sysctl interface at the 1st result, abstract a single concrete implementation of *directSysctl (iface)
func NewDirectSysctl(fs afero.Fs, procFs string) Sysctl {
                                                 ^
pkg/endpointmanager/cell.go:245:60: opaque: newEndpointSynchronizer function return EndpointResourceSynchronizer interface at the 1st result, abstract a single concrete implementation of *EndpointSynchronizer (iface)
func newEndpointSynchronizer(p endpointSynchronizerParams) EndpointResourceSynchronizer {
                                                           ^
pkg/inctimer/inctimer.go:31:13: opaque: New function return IncTimer interface at the 1st result, abstract a single concrete implementation of *incTimer (iface)
func New() (IncTimer, func() bool) {
            ^
pkg/ipam/crd.go:637:197: opaque: newCRDAllocator function return Allocator interface at the 1st result, abstract a single concrete implementation of *crdAllocator (iface)
func newCRDAllocator(family Family, c *option.DaemonConfig, owner Owner, localNodeStore *node.LocalNodeStore, clientset client.Clientset, k8sEventReg K8sEventRegister, mtuConfig MtuConfiguration) Allocator {
                                                                                                                                                                                                    ^
pkg/ipam/hostscope.go:20:42: opaque: newHostScopeAllocator function return Allocator interface at the 1st result, abstract a single concrete implementation of *hostScopeAllocator (iface)
func newHostScopeAllocator(n *net.IPNet) Allocator {
                                         ^
pkg/k8s/client/cell.go:511:42: opaque: NewFakeClientset function return Clientset interface at the 2nd result, abstract a single concrete implementation of *FakeClientset (iface)
func NewFakeClientset() (*FakeClientset, Clientset) {
                                         ^
pkg/kvstore/etcd.go:94:22: opaque: newEtcdModule function return backendModule interface at the 1st result, abstract a single concrete implementation of *etcdModule (iface)
func newEtcdModule() backendModule {
                     ^
pkg/kvstore/store/cell.go:43:40: opaque: NewFactory function return Factory interface at the 1st result, abstract a single concrete implementation of *factoryImpl (iface)
func NewFactory(storeMetrics *Metrics) Factory {
                                       ^
pkg/kvstore/store/store.go:194:22: opaque: KVPairCreator function return Key interface at the 1st result, abstract a single concrete implementation of *KVPair (iface)
func KVPairCreator() Key                  { return &KVPair{} }
                     ^
pkg/kvstore/store/syncstore.go:118:117: opaque: newWorkqueueSyncStore function return SyncStore interface at the 1st result, abstract a single concrete implementation of *wqSyncStore (iface)
func newWorkqueueSyncStore(clusterName string, backend SyncStoreBackend, prefix string, m *Metrics, opts ...WSSOpt) SyncStore {
                                                                                                                    ^
Command Mean [s] Min [s] Max [s] Relative
iface 6.003 ± 0.120 5.879 6.302 2.04 ± 0.04
goconst 2.938 ± 0.021 2.905 2.970 1.00
durationcheck 5.879 ± 0.047 5.818 5.967 2.00 ± 0.02

spf13/cobra

Command Mean [ms] Min [ms] Max [ms] Relative
iface 343.0 ± 4.8 337.0 354.0 1.38 ± 0.03
goconst 247.8 ± 3.0 244.1 252.6 1.00
durationcheck 341.8 ± 5.9 335.2 353.5 1.38 ± 0.03

hashicorp/consul

agent/setup.go:71:6: identical: interface NetRPC contains identical methods or type constraints from another interface, causing redundancy (iface)
type NetRPC interface {
     ^
agent/user_event_test.go:237:6: identical: interface RPC contains identical methods or type constraints from another interface, causing redundancy (iface)
type RPC interface {
     ^
agent/grpc-external/services/peerstream/subscription_manager.go:41:6: identical: interface SubscriptionBackend contains identical methods or type constraints from another interface, causing redundancy (iface)
type SubscriptionBackend interface {
     ^
agent/grpc-external/services/peerstream/subscription_view.go:21:6: identical: interface Subscriber contains identical methods or type constraints from another interface, causing redundancy (iface)
type Subscriber interface {
     ^
agent/proxycfg/data_sources.go:157:6: identical: interface ConfigEntryList contains identical methods or type constraints from another interface, causing redundancy (iface)
type ConfigEntryList interface {
     ^
agent/proxycfg/data_sources.go:175:6: identical: interface GatewayServices contains identical methods or type constraints from another interface, causing redundancy (iface)
type GatewayServices interface {
     ^
agent/proxycfg/data_sources.go:180:6: identical: interface ServiceGateways contains identical methods or type constraints from another interface, causing redundancy (iface)
type ServiceGateways interface {
     ^
agent/proxycfg/data_sources.go:185:6: identical: interface Health contains identical methods or type constraints from another interface, causing redundancy (iface)
type Health interface {
     ^
agent/proxycfg/data_sources.go:203:6: identical: interface IntentionUpstreams contains identical methods or type constraints from another interface, causing redundancy (iface)
type IntentionUpstreams interface {
     ^
agent/proxycfg/data_sources.go:197:6: identical: interface Intentions contains identical methods or type constraints from another interface, causing redundancy (iface)
type Intentions interface {
     ^
agent/proxycfg/data_sources.go:244:6: identical: interface ServiceList contains identical methods or type constraints from another interface, causing redundancy (iface)
type ServiceList interface {
     ^
agent/proxycfg/data_sources.go:139:6: identical: interface CARoots contains identical methods or type constraints from another interface, causing redundancy (iface)
type CARoots interface {
     ^
agent/proxycfg/data_sources.go:262:6: identical: interface ExportedPeeredServices contains identical methods or type constraints from another interface, causing redundancy (iface)
type ExportedPeeredServices interface {
     ^
agent/proxycfg/data_sources.go:151:6: identical: interface ConfigEntry contains identical methods or type constraints from another interface, causing redundancy (iface)
type ConfigEntry interface {
     ^
agent/proxycfg/data_sources.go:169:6: identical: interface FederationStateListMeshGateways contains identical methods or type constraints from another interface, causing redundancy (iface)
type FederationStateListMeshGateways interface {
     ^
command/acl/authmethod/formatter.go:44:40: opaque: newPrettyFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *prettyFormatter (iface)
func newPrettyFormatter(showMeta bool) Formatter {
                                       ^
command/acl/authmethod/formatter.go:127:38: opaque: newJSONFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *jsonFormatter (iface)
func newJSONFormatter(showMeta bool) Formatter {
                                     ^
command/acl/bindingrule/formatter.go:44:40: opaque: newPrettyFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *prettyFormatter (iface)
func newPrettyFormatter(showMeta bool) Formatter {
                                       ^
command/acl/bindingrule/formatter.go:115:38: opaque: newJSONFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *jsonFormatter (iface)
func newJSONFormatter(showMeta bool) Formatter {
                                     ^
command/acl/policy/formatter.go:45:40: opaque: newPrettyFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *prettyFormatter (iface)
func newPrettyFormatter(showMeta bool) Formatter {
                                       ^
command/acl/policy/formatter.go:109:38: opaque: newJSONFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *jsonFormatter (iface)
func newJSONFormatter(showMeta bool) Formatter {
                                     ^
agent/consul/authmethod/authmethods.go:119:17: opaque: newCache function return Cache interface at the 1st result, abstract a single concrete implementation of *authMethodCache (iface)
func newCache() Cache {
                ^
agent/consul/authmethod/authmethods_ce.go:19:17: opaque: NewCache function return Cache interface at the 1st result, abstract a single concrete implementation of *syncCache (iface)
func NewCache() Cache {
                ^
acl/policy_authorizer_ce.go:20:66: opaque: NewPolicyAuthorizer function return Authorizer interface at the 1st result, abstract a single concrete implementation of *policyAuthorizer (iface)
func NewPolicyAuthorizer(policies []*Policy, entConfig *Config) (Authorizer, error) {
                                                                 ^
agent/config/default.go:20:22: opaque: DefaultSource function return Source interface at the 1st result, abstract a single concrete implementation of FileSource (iface)
func DefaultSource() Source {
                     ^
agent/config/default.go:172:18: opaque: DevSource function return Source interface at the 1st result, abstract a single concrete implementation of FileSource (iface)
func DevSource() Source {
                 ^
agent/config/default.go:221:22: opaque: NonUserSource function return Source interface at the 1st result, abstract a single concrete implementation of FileSource (iface)
func NonUserSource() Source {
                     ^
agent/config/default.go:252:72: opaque: versionSource function return Source interface at the 1st result, abstract a single concrete implementation of LiteralSource (iface)
func versionSource(rev, ver, verPre, meta string, buildDate time.Time) Source {
                                                                       ^
agent/config/default.go:275:28: opaque: DefaultConsulSource function return Source interface at the 1st result, abstract a single concrete implementation of FileSource (iface)
func DefaultConsulSource() Source {
                           ^
agent/config/default.go:303:24: opaque: DevConsulSource function return Source interface at the 1st result, abstract a single concrete implementation of LiteralSource (iface)
func DevConsulSource() Source {
                       ^
agent/config/default_ce.go:11:32: opaque: DefaultEnterpriseSource function return Source interface at the 1st result, abstract a single concrete implementation of LiteralSource (iface)
func DefaultEnterpriseSource() Source {
                               ^
agent/config/default_ce.go:17:33: opaque: OverrideEnterpriseSource function return Source interface at the 1st result, abstract a single concrete implementation of LiteralSource (iface)
func OverrideEnterpriseSource() Source {
                                ^
agent/consul/controller/controller.go:125:65: opaque: New function return Controller interface at the 1st result, abstract a single concrete implementation of *controller (iface)
func New(publisher state.EventPublisher, reconciler Reconciler) Controller {
                                                                ^
agent/consul/controller/queue/defer.go:57:52: opaque: NewDeferQueue function return DeferQueue[T] interface at the 1st result, abstract a single concrete implementation of *deferQueue[T] (iface)
func NewDeferQueue[T ItemType](tick time.Duration) DeferQueue[T] {
                                                   ^
agent/consul/controller/queue/queue.go:70:91: opaque: RunWorkQueue function return WorkQueue[T] interface at the 1st result, abstract a single concrete implementation of *queue[T] (iface)
func RunWorkQueue[T ItemType](ctx context.Context, baseBackoff, maxBackoff time.Duration) WorkQueue[T] {
                                                                                          ^
agent/consul/controller/queue/rate.go:34:58: opaque: NewRateLimiter function return Limiter[T] interface at the 1st result, abstract a single concrete implementation of *ratelimiter[T] (iface)
func NewRateLimiter[T ItemType](base, max time.Duration) Limiter[T] {
                                                         ^
agent/consul/rate/handler.go:405:33: opaque: NullRequestLimitsHandler function return RequestLimitsHandler interface at the 1st result, abstract a single concrete implementation of nullRequestLimitsHandler (iface)
func NullRequestLimitsHandler() RequestLimitsHandler {
                                ^
agent/consul/usagemetrics/usagemetrics_ce.go:8:55: opaque: newTenancyUsageReporter function return usageReporter interface at the 1st result, abstract a single concrete implementation of *baseUsageReporter (iface)
func newTenancyUsageReporter(u *UsageMetricsReporter) usageReporter {
                                                      ^
agent/leafcert/cached_roots.go:15:61: opaque: NewCachedRootsReader function return RootsReader interface at the 1st result, abstract a single concrete implementation of *agentCacheRootsReader (iface)
func NewCachedRootsReader(cache cacheshim.Cache, dc string) RootsReader {
                                                            ^
agent/leafcert/signer_netrpc.go:20:41: opaque: NewNetRPCCertSigner function return CertSigner interface at the 1st result, abstract a single concrete implementation of *netRPCCertSigner (iface)
func NewNetRPCCertSigner(netRPC NetRPC) CertSigner {
                                        ^
command/acl/role/formatter.go:45:40: opaque: newPrettyFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *prettyFormatter (iface)
func newPrettyFormatter(showMeta bool) Formatter {
                                       ^
command/acl/role/formatter.go:179:38: opaque: newJSONFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *jsonFormatter (iface)
func newJSONFormatter(showMeta bool) Formatter {
                                     ^
command/acl/templatedpolicy/formatter.go:46:40: opaque: newPrettyFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *prettyFormatter (iface)
func newPrettyFormatter(showMeta bool) Formatter {
                                       ^
command/acl/templatedpolicy/formatter.go:50:38: opaque: newJSONFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *jsonFormatter (iface)
func newJSONFormatter(showMeta bool) Formatter {
                                     ^
command/acl/token/formatter.go:51:40: opaque: newPrettyFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *prettyFormatter (iface)
func newPrettyFormatter(showMeta bool) Formatter {
                                       ^
command/acl/token/formatter.go:399:38: opaque: newJSONFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *jsonFormatter (iface)
func newJSONFormatter(showMeta bool) Formatter {
                                     ^
command/operator/autopilot/state/formatter.go:44:27: opaque: newPrettyFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *prettyFormatter (iface)
func newPrettyFormatter() Formatter {
                          ^
command/operator/autopilot/state/formatter.go:196:25: opaque: newJSONFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *jsonFormatter (iface)
func newJSONFormatter() Formatter {
                        ^
command/snapshot/inspect/formatter.go:30:27: opaque: newPrettyFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *prettyFormatter (iface)
func newPrettyFormatter() Formatter {
                          ^
command/snapshot/inspect/formatter.go:84:25: opaque: newJSONFormatter function return Formatter interface at the 1st result, abstract a single concrete implementation of *jsonFormatter (iface)
func newJSONFormatter() Formatter {
                        ^
Command Mean [s] Min [s] Max [s] Relative
iface 4.760 ± 0.050 4.680 4.832 1.87 ± 0.02
goconst 2.547 ± 0.021 2.506 2.587 1.00
durationcheck 4.706 ± 0.041 4.642 4.782 1.85 ± 0.02

go-delve/delve

pkg/dwarf/godwarf/fakes.go:10:36: opaque: FakeSliceType function return Type interface at the 1st result, abstract a single concrete implementation of *SliceType (iface)
func FakeSliceType(fieldType Type) Type {
                                   ^
pkg/proc/mem.go:66:44: opaque: CreateLoadedCachedMemory function return MemoryReadWriter interface at the 1st result, abstract a single concrete implementation of *memCache (iface)
func CreateLoadedCachedMemory(data []byte) MemoryReadWriter {
                                           ^
service/server.go:5:6: unused: interface Server is declared but not used within the package (iface)
type Server interface {
     ^
service/client.go:11:6: unused: interface Client is declared but not used within the package (iface)
type Client interface {
     ^
service/rpccallback.go:4:6: unused: interface RPCCallback is declared but not used within the package (iface)
type RPCCallback interface {
     ^
pkg/dwarf/loclist/dwarf2_loclist.go:10:6: unused: interface Reader is declared but not used within the package (iface)
type Reader interface {
     ^
service/test/common_test.go:64:6: unused: interface BreakpointLister is declared but not used within the package (iface)
type BreakpointLister interface {
     ^
Command Mean [ms] Min [ms] Max [ms] Relative
iface 918.7 ± 17.7 895.5 949.3 1.66 ± 0.04
goconst 552.7 ± 8.4 544.9 570.7 1.00
durationcheck 920.6 ± 14.4 901.9 948.3 1.67 ± 0.04

etcd-io/etcd

tools/local-tester/bridge/dispatch.go:49:26: opaque: newDispatcherPool function return dispatcher interface at the 1st result, abstract a single concrete implementation of *dispatcherPool (iface)
func newDispatcherPool() dispatcher {
                         ^
tools/local-tester/bridge/dispatch.go:126:31: opaque: newDispatcherImmediate function return dispatcher interface at the 1st result, abstract a single concrete implementation of *dispatcherImmediate (iface)
func newDispatcherImmediate() dispatcher {
                              ^
Command Mean [ms] Min [ms] Max [ms] Relative
iface 575.3 ± 5.9 565.0 584.9 1.80 ± 0.04
goconst 320.5 ± 6.0 309.8 329.6 1.00
durationcheck 573.7 ± 9.6 554.7 585.6 1.79 ± 0.04

go-gitea/gitea

models/auth/source.go:79:6: unused: interface SSHKeyProvider is declared but not used within the package (iface)
type SSHKeyProvider interface {
     ^
models/migrations/migrations.go:51:61: opaque: NewMigration function return Migration interface at the 1st result, abstract a single concrete implementation of *migration (iface)
func NewMigration(desc string, fn func(*xorm.Engine) error) Migration {
                                                            ^
models/user/external_login_user.go:84:6: unused: interface ExternalUserRemappable is declared but not used within the package (iface)
type ExternalUserRemappable interface {
     ^
modules/auth/password/hash/hash.go:26:6: unused: interface PasswordHasher is declared but not used within the package (iface)
type PasswordHasher interface {
     ^
modules/charset/escape_stream.go:21:87: opaque: NewEscapeStreamer function return HTMLStreamer interface at the 1st result, abstract a single concrete implementation of *escapeStreamer (iface)
func NewEscapeStreamer(locale translation.Locale, next HTMLStreamer, allowed ...rune) HTMLStreamer {
                                                                                      ^
modules/git/batch_reader.go:47:63: opaque: catFileBatchCheck function return WriteCloserError interface at the 1st result, abstract a single concrete implementation of *io.PipeWriter (iface)
func catFileBatchCheck(ctx context.Context, repoPath string) (WriteCloserError, *bufio.Reader, func()) {
                                                              ^
modules/git/batch_reader.go:97:58: opaque: catFileBatch function return WriteCloserError interface at the 1st result, abstract a single concrete implementation of *io.PipeWriter (iface)
func catFileBatch(ctx context.Context, repoPath string) (WriteCloserError, *bufio.Reader, func()) {
                                                         ^
modules/globallock/memory_locker.go:18:24: opaque: NewMemoryLocker function return Locker interface at the 1st result, abstract a single concrete implementation of *memoryLocker (iface)
func NewMemoryLocker() Locker {
                       ^
modules/globallock/redis_locker.go:36:40: opaque: NewRedisLocker function return Locker interface at the 1st result, abstract a single concrete implementation of *redisLocker (iface)
func NewRedisLocker(connection string) Locker {
                                       ^
modules/indexer/code/internal/indexer.go:34:24: opaque: NewDummyIndexer function return Indexer interface at the 1st result, abstract a single concrete implementation of *dummyIndexer (iface)
func NewDummyIndexer() Indexer {
                       ^
modules/indexer/internal/indexer.go:23:24: opaque: NewDummyIndexer function return Indexer interface at the 1st result, abstract a single concrete implementation of *dummyIndexer (iface)
func NewDummyIndexer() Indexer {
                       ^
modules/indexer/issues/internal/indexer.go:22:24: opaque: NewDummyIndexer function return Indexer interface at the 1st result, abstract a single concrete implementation of *dummyIndexer (iface)
func NewDummyIndexer() Indexer {
                       ^
modules/log/event_writer.go:14:6: identical: interface EventWriter contains identical methods or type constraints from another interface, causing redundancy (iface)
type EventWriter interface {
     ^
modules/log/event_writer_base.go:17:6: identical: interface EventWriterBase contains identical methods or type constraints from another interface, causing redundancy (iface)
type EventWriterBase interface {
     ^
modules/log/event_writer_conn.go:25:67: opaque: NewEventWriterConn function return EventWriter interface at the 1st result, abstract a single concrete implementation of *eventWriterConn (iface)
func NewEventWriterConn(writerName string, writerMode WriterMode) EventWriter {
                                                                  ^
modules/log/event_writer_console.go:27:58: opaque: NewEventWriterConsole function return EventWriter interface at the 1st result, abstract a single concrete implementation of *eventWriterConsole (iface)
func NewEventWriterConsole(name string, mode WriterMode) EventWriter {
                                                         ^
modules/log/event_writer_file.go:29:55: opaque: NewEventWriterFile function return EventWriter interface at the 1st result, abstract a single concrete implementation of *eventWriterFile (iface)
func NewEventWriterFile(name string, mode WriterMode) EventWriter {
                                                      ^
modules/log/logger_global.go:69:29: opaque: GetLogger function return Logger interface at the 1st result, abstract a single concrete implementation of *LoggerImpl (iface)
func GetLogger(name string) Logger {
                            ^
modules/log/misc.go:15:46: opaque: BaseLoggerToGeneralLogger function return Logger interface at the 1st result, abstract a single concrete implementation of *baseToLogger (iface)
func BaseLoggerToGeneralLogger(b BaseLogger) Logger {
                                             ^
modules/migration/downloader.go:31:6: unused: interface DownloaderFactory is declared but not used within the package (iface)
type DownloaderFactory interface {
     ^
modules/migration/uploader.go:8:6: unused: interface Uploader is declared but not used within the package (iface)
type Uploader interface {
     ^
modules/packages/conda/metadata.go:87:6: unused: interface ReaderAndReaderAt is declared but not used within the package (iface)
type ReaderAndReaderAt interface {
     ^
modules/packages/hashed_buffer.go:13:6: unused: interface HashedSizeReader is declared but not used within the package (iface)
type HashedSizeReader interface {
     ^
modules/queue/base_channel.go:27:59: opaque: newBaseChannelGeneric function return baseQueue interface at the 1st result, abstract a single concrete implementation of *baseChannel (iface)
func newBaseChannelGeneric(cfg *BaseConfig, unique bool) (baseQueue, error) {
                                                          ^
modules/queue/base_dummy.go:12:50: opaque: newBaseDummy function return baseQueue interface at the 1st result, abstract a single concrete implementation of *baseDummy (iface)
func newBaseDummy(cfg *BaseConfig, unique bool) (baseQueue, error) {
                                                 ^
modules/structs/repo_file.go:99:6: unused: interface FileOptionInterface is declared but not used within the package (iface)
type FileOptionInterface interface {
     ^
modules/translation/i18n/localestore.go:37:23: opaque: NewLocaleStore function return LocaleStore interface at the 1st result, abstract a single concrete implementation of *localeStore (iface)
func NewLocaleStore() LocaleStore {
                      ^
modules/translation/translation.go:154:29: opaque: NewLocale function return Locale interface at the 1st result, abstract a single concrete implementation of *locale (iface)
func NewLocale(lang string) Locale {
                            ^
modules/web/types/response.go:8:6: unused: interface ResponseStatusProvider is declared but not used within the package (iface)
type ResponseStatusProvider interface {
     ^
services/actions/interface.go:9:6: unused: interface API is declared but not used within the package (iface)
type API interface {
     ^
services/context/csrf.go:89:40: opaque: NewCSRFProtector function return CSRFProtector interface at the 1st result, abstract a single concrete implementation of *csrfProtector (iface)
func NewCSRFProtector(opt CsrfOptions) CSRFProtector {
                                       ^
Command Mean [s] Min [s] Max [s] Relative
iface 3.568 ± 0.030 3.499 3.603 1.95 ± 0.02
goconst 1.828 ± 0.015 1.806 1.844 1.00
durationcheck 3.509 ± 0.035 3.449 3.568 1.92 ± 0.02

google/go-github

Command Mean [s] Min [s] Max [s] Relative
iface 1.653 ± 0.015 1.633 1.681 2.18 ± 0.03
goconst 0.759 ± 0.007 0.745 0.768 1.00
durationcheck 1.694 ± 0.054 1.618 1.793 2.23 ± 0.07

golangci/golangci-lint

Command Mean [s] Min [s] Max [s] Relative
iface 1.008 ± 0.010 0.988 1.020 1.78 ± 0.03
goconst 0.566 ± 0.009 0.555 0.582 1.00
durationcheck 0.999 ± 0.011 0.982 1.021 1.76 ± 0.03

goreleaser/goreleaser

internal/client/git.go:33:40: opaque: NewGitUploadClient function return FilesCreator interface at the 1st result, abstract a single concrete implementation of *gitClient (iface)
func NewGitUploadClient(branch string) FilesCreator {
                                       ^
internal/client/github.go:40:74: opaque: NewGitHubReleaseNotesGenerator function return ReleaseNotesGenerator interface at the 1st result, abstract a single concrete implementation of *githubClient (iface)
func NewGitHubReleaseNotesGenerator(ctx *context.Context, token string) (ReleaseNotesGenerator, error) {
                                                                         ^
internal/semerrgroup/sem.go:47:32: opaque: NewBlockingFirst function return Group interface at the 1st result, abstract a single concrete implementation of *blockingFirstGroup (iface)
func NewBlockingFirst(g Group) Group {
                               ^
internal/semerrgroup/sem.go:54:20: opaque: New function return Group interface at the 1st result, abstract a single concrete implementation of *golang.org/x/sync/errgroup.Group (iface)
func New(size int) Group {
                   ^
internal/semerrgroup/sem.go:63:28: opaque: NewSkipAware function return Group interface at the 1st result, abstract a single concrete implementation of *skipAwareGroup (iface)
func NewSkipAware(g Group) Group {
                           ^
Command Mean [s] Min [s] Max [s] Relative
iface 1.554 ± 0.023 1.530 1.609 2.05 ± 0.05
goconst 0.758 ± 0.016 0.741 0.796 1.00
durationcheck 1.546 ± 0.024 1.507 1.580 2.04 ± 0.05

grpc/grpc-go

mem/buffer_pool.go:69:44: opaque: NewTieredBufferPool function return BufferPool interface at the 1st result, abstract a single concrete implementation of *tieredBufferPool (iface)
func NewTieredBufferPool(poolSizes ...int) BufferPool {
                                           ^
codec.go:49:32: opaque: newCodecV0Bridge function return baseCodec interface at the 1st result, abstract a single concrete implementation of codecV0Bridge (iface)
func newCodecV0Bridge(c Codec) baseCodec {
                               ^
dialoptions.go:137:36: opaque: newDisableGlobalDialOptions function return DialOption interface at the 1st result, abstract a single concrete implementation of *disableGlobalDialOptions (iface)
func newDisableGlobalDialOptions() DialOption {
                                   ^
dialoptions.go:167:44: opaque: newJoinDialOption function return DialOption interface at the 1st result, abstract a single concrete implementation of *joinDialOption (iface)
func newJoinDialOption(opts ...DialOption) DialOption {
                                           ^
dialoptions.go:179:38: opaque: WithSharedWriteBuffer function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithSharedWriteBuffer(val bool) DialOption {
                                     ^
dialoptions.go:191:33: opaque: WithWriteBufferSize function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithWriteBufferSize(s int) DialOption {
                                ^
dialoptions.go:203:32: opaque: WithReadBufferSize function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithReadBufferSize(s int) DialOption {
                               ^
dialoptions.go:212:37: opaque: WithInitialWindowSize function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithInitialWindowSize(s int32) DialOption {
                                    ^
dialoptions.go:221:41: opaque: WithInitialConnWindowSize function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithInitialConnWindowSize(s int32) DialOption {
                                        ^
dialoptions.go:238:48: opaque: WithDefaultCallOptions function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithDefaultCallOptions(cos ...CallOption) DialOption {
                                               ^
dialoptions.go:258:36: opaque: WithCompressor function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithCompressor(cp Compressor) DialOption {
                                   ^
dialoptions.go:274:40: opaque: WithDecompressor function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithDecompressor(dc Decompressor) DialOption {
                                       ^
dialoptions.go:288:41: opaque: WithConnectParams function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithConnectParams(p ConnectParams) DialOption {
                                        ^
dialoptions.go:319:47: opaque: withBackoff function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func withBackoff(bs internalbackoff.Strategy) DialOption {
                                              ^
dialoptions.go:334:18: opaque: WithBlock function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithBlock() DialOption {
                 ^
dialoptions.go:350:34: opaque: WithReturnConnectionError function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithReturnConnectionError() DialOption {
                                 ^
dialoptions.go:366:21: opaque: WithInsecure function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithInsecure() DialOption {
                    ^
dialoptions.go:379:20: opaque: WithNoProxy function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithNoProxy() DialOption {
                   ^
dialoptions.go:388:71: opaque: WithTransportCredentials function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithTransportCredentials(creds credentials.TransportCredentials) DialOption {
                                                                      ^
dialoptions.go:396:65: opaque: WithPerRPCCredentials function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithPerRPCCredentials(creds credentials.PerRPCCredentials) DialOption {
                                                                ^
dialoptions.go:410:50: opaque: WithCredentialsBundle function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithCredentialsBundle(b credentials.Bundle) DialOption {
                                                 ^
dialoptions.go:421:35: opaque: WithTimeout function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithTimeout(d time.Duration) DialOption {
                                  ^
dialoptions.go:442:75: opaque: WithContextDialer function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithContextDialer(f func(context.Context, string) (net.Conn, error)) DialOption {
                                                                          ^
dialoptions.go:471:40: opaque: WithStatsHandler function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithStatsHandler(h stats.Handler) DialOption {
                                       ^
dialoptions.go:485:44: opaque: withBinaryLogger function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func withBinaryLogger(bl binarylog.Logger) DialOption {
                                           ^
dialoptions.go:505:37: opaque: FailOnNonTempDialError function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func FailOnNonTempDialError(f bool) DialOption {
                                    ^
dialoptions.go:513:30: opaque: WithUserAgent function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithUserAgent(s string) DialOption {
                             ^
dialoptions.go:523:57: opaque: WithKeepaliveParams function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithKeepaliveParams(kp keepalive.ClientParameters) DialOption {
                                                        ^
dialoptions.go:535:53: opaque: WithUnaryInterceptor function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithUnaryInterceptor(f UnaryClientInterceptor) DialOption {
                                                    ^
dialoptions.go:546:72: opaque: WithChainUnaryInterceptor function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithChainUnaryInterceptor(interceptors ...UnaryClientInterceptor) DialOption {
                                                                       ^
dialoptions.go:554:55: opaque: WithStreamInterceptor function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithStreamInterceptor(f StreamClientInterceptor) DialOption {
                                                      ^
dialoptions.go:565:74: opaque: WithChainStreamInterceptor function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithChainStreamInterceptor(interceptors ...StreamClientInterceptor) DialOption {
                                                                         ^
dialoptions.go:573:30: opaque: WithAuthority function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithAuthority(a string) DialOption {
                             ^
dialoptions.go:587:50: opaque: WithChannelzParentID function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithChannelzParentID(c channelz.Identifier) DialOption {
                                                 ^
dialoptions.go:599:33: opaque: WithDisableServiceConfig function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithDisableServiceConfig() DialOption {
                                ^
dialoptions.go:618:41: opaque: WithDefaultServiceConfig function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithDefaultServiceConfig(s string) DialOption {
                                        ^
dialoptions.go:628:25: opaque: WithDisableRetry function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithDisableRetry() DialOption {
                        ^
dialoptions.go:646:38: opaque: WithMaxHeaderListSize function return DialOption interface at the 1st result, abstract a single concrete implementation of MaxHeaderListSizeDialOption (iface)
func WithMaxHeaderListSize(s uint32) DialOption {
                                     ^
dialoptions.go:659:31: opaque: WithDisableHealthCheck function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithDisableHealthCheck() DialOption {
                              ^
dialoptions.go:669:52: opaque: withHealthCheckFunc function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func withHealthCheckFunc(f internal.HealthChecker) DialOption {
                                                   ^
dialoptions.go:697:53: opaque: withMinConnectDeadline function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func withMinConnectDeadline(f func() time.Duration) DialOption {
                                                    ^
dialoptions.go:705:34: opaque: withDefaultScheme function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func withDefaultScheme(s string) DialOption {
                                 ^
dialoptions.go:720:44: opaque: WithResolvers function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithResolvers(rs ...resolver.Builder) DialOption {
                                           ^
dialoptions.go:740:39: opaque: WithIdleTimeout function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithIdleTimeout(d time.Duration) DialOption {
                                      ^
dialoptions.go:754:33: opaque: WithMaxCallAttempts function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func WithMaxCallAttempts(n int) DialOption {
                                ^
dialoptions.go:763:48: opaque: withBufferPool function return DialOption interface at the 1st result, abstract a single concrete implementation of *funcDialOption (iface)
func withBufferPool(bufferPool mem.BufferPool) DialOption {
                                               ^
rpc_util.go:120:28: opaque: NewGZIPDecompressor function return Decompressor interface at the 1st result, abstract a single concrete implementation of *gzipDecompressor (iface)
func NewGZIPDecompressor() Decompressor {
                           ^
rpc_util.go:196:21: opaque: StaticMethod function return CallOption interface at the 1st result, abstract a single concrete implementation of StaticMethodCallOption (iface)
func StaticMethod() CallOption {
                    ^
rpc_util.go:208:30: opaque: Header function return CallOption interface at the 1st result, abstract a single concrete implementation of HeaderCallOption (iface)
func Header(md *metadata.MD) CallOption {
                             ^
rpc_util.go:230:31: opaque: Trailer function return CallOption interface at the 1st result, abstract a single concrete implementation of TrailerCallOption (iface)
func Trailer(md *metadata.MD) CallOption {
                              ^
Command Mean [s] Min [s] Max [s] Relative
iface 1.575 ± 0.074 1.512 1.721 1.77 ± 0.09
goconst 0.888 ± 0.020 0.867 0.937 1.00
durationcheck 1.510 ± 0.010 1.486 1.522 1.70 ± 0.04

gohugoio/hugo

resources/resource/resources.go:159:6: identical: interface translatedResource contains identical methods or type constraints from another interface, causing redundancy (iface)
type translatedResource interface {
     ^
resources/resource/resourcetypes.go:227:6: identical: interface TranslationKeyProvider contains identical methods or type constraints from another interface, causing redundancy (iface)
type TranslationKeyProvider interface {
     ^
codegen/methods_test.go:94:6: identical: interface IEOnly contains identical methods or type constraints from another interface, causing redundancy (iface)
type IEOnly interface {
     ^
codegen/methods2_test.go:16:6: identical: interface IEmbed contains identical methods or type constraints from another interface, causing redundancy (iface)
type IEmbed interface {
     ^
common/hcontext/context.go:25:55: opaque: NewContextDispatcher function return ContextDispatcher[T] interface at the 1st result, abstract a single concrete implementation of keyInContext[T, R] (iface)
func NewContextDispatcher[T any, R comparable](key R) ContextDispatcher[T] {
                                                      ^
common/loggers/logger.go:50:24: opaque: New function return Logger interface at the 1st result, abstract a single concrete implementation of *logAdapter (iface)
func New(opts Options) Logger {
                       ^
markup/converter/converter.go:56:84: opaque: NewProvider function return Provider interface at the 1st result, abstract a single concrete implementation of newConverter (iface)
func NewProvider(name string, create func(ctx DocumentContext) (Converter, error)) Provider {
                                                                                   ^
resources/resource/resourcetypes.go:45:44: opaque: NewResourceError function return ResourceError interface at the 1st result, abstract a single concrete implementation of *resourceError (iface)
func NewResourceError(err error, data any) ResourceError {
                                           ^
resources/resource/resourcetypes.go:298:74: opaque: NewResourceTypesProvider function return ResourceTypesProvider interface at the 1st result, abstract a single concrete implementation of resourceTypesHolder (iface)
func NewResourceTypesProvider(mediaType media.Type, resourceType string) ResourceTypesProvider {
                                                                         ^
common/herrors/file_error.go:171:30: opaque: NewFileError function return FileError interface at the 1st result, abstract a single concrete implementation of *fileError (iface)
func NewFileError(err error) FileError {
                             ^
common/herrors/file_error.go:180:51: opaque: NewFileErrorFromName function return FileError interface at the 1st result, abstract a single concrete implementation of *fileError (iface)
func NewFileErrorFromName(err error, name string) FileError {
                                                  ^
common/herrors/file_error.go:192:56: opaque: NewFileErrorFromPos function return FileError interface at the 1st result, abstract a single concrete implementation of *fileError (iface)
func NewFileErrorFromPos(err error, pos text.Position) FileError {
                                                       ^
common/hugio/readers.go:51:44: opaque: NewReadSeekerNoOpCloser function return ReadSeekCloser interface at the 1st result, abstract a single concrete implementation of readSeekerNopCloser (iface)
func NewReadSeekerNoOpCloser(r ReadSeeker) ReadSeekCloser {
                                           ^
common/hugio/readers.go:57:56: opaque: NewReadSeekerNoOpCloserFromString function return ReadSeekCloser interface at the 1st result, abstract a single concrete implementation of stringReadSeeker (iface)
func NewReadSeekerNoOpCloserFromString(content string) ReadSeekCloser {
                                                       ^
common/maps/scratch.go:46:21: opaque: NewScratcher function return Scratcher interface at the 1st result, abstract a single concrete implementation of scratcher (iface)
func NewScratcher() Scratcher {
                    ^
common/rungroup/rungroup.go:42:53: opaque: Run function return Group[T] interface at the 1st result, abstract a single concrete implementation of *runGroup[T] (iface)
func Run[T any](ctx context.Context, cfg Config[T]) Group[T] {
                                                    ^
config/defaultConfigProvider.go:66:12: opaque: New function return Provider interface at the 1st result, abstract a single concrete implementation of *defaultConfigProvider (iface)
func New() Provider {
           ^
config/defaultConfigProvider.go:73:34: opaque: NewFrom function return Provider interface at the 1st result, abstract a single concrete implementation of *defaultConfigProvider (iface)
func NewFrom(params maps.Params) Provider {
                                 ^
hugolib/shortcode.go:353:4: opaque: doRenderShortcode function return shortcodeRenderer interface at the 1st result, abstract a single concrete implementation of prerenderedShortcode (iface)
) (shortcodeRenderer, error) {
   ^
identity/identity.go:41:53: opaque: NewManager function return Manager interface at the 1st result, abstract a single concrete implementation of *identityManager (iface)
func NewManager(name string, opts ...ManagerOption) Manager {
                                                    ^
identity/identity.go:178:66: opaque: NewFindFirstManagerIdentityProvider function return FindFirstManagerIdentityProvider interface at the 1st result, abstract a single concrete implementation of findFirstManagerIdentity (iface)
func NewFindFirstManagerIdentityProvider(m Manager, id Identity) FindFirstManagerIdentityProvider {
                                                                 ^
identity/identity.go:470:24: opaque: Or function return Identity interface at the 1st result, abstract a single concrete implementation of orIdentity (iface)
func Or(a, b Identity) Identity {
                       ^
identity/predicate_identity.go:27:38: opaque: NewGlobIdentity function return Identity interface at the 1st result, abstract a single concrete implementation of *predicateIdentity (iface)
func NewGlobIdentity(pattern string) Identity {
                                     ^
markup/highlight/highlight.go:55:22: opaque: New function return Highlighter interface at the 1st result, abstract a single concrete implementation of chromaHighlighter (iface)
func New(cfg Config) Highlighter {
                     ^
metrics/metrics.go:81:39: opaque: NewProvider function return Provider interface at the 1st result, abstract a single concrete implementation of *Store (iface)
func NewProvider(calculateHints bool) Provider {
                                      ^
navigation/pagemenus.go:104:3: opaque: NewMenuQueryProvider function return MenuQueryProvider interface at the 1st result, abstract a single concrete implementation of *pageMenus (iface)
) MenuQueryProvider {
  ^
resources/resource.go:205:69: opaque: NewFeatureNotAvailableTransformer function return ResourceTransformation interface at the 1st result, abstract a single concrete implementation of transformerNotAvailable (iface)
func NewFeatureNotAvailableTransformer(key string, elements ...any) ResourceTransformation {
                                                                    ^
resources/page/site.go:170:23: opaque: WrapSite function return Site interface at the 1st result, abstract a single concrete implementation of *siteWrapper (iface)
func WrapSite(s Site) Site {
                      ^
resources/page/site.go:498:48: opaque: NewDummyHugoSite function return Site interface at the 1st result, abstract a single concrete implementation of testSite (iface)
func NewDummyHugoSite(conf config.AllProvider) Site {
                                               ^
resources/postpub/postpub.go:51:58: opaque: NewPostPublishResource function return PostPublishedResource interface at the 1st result, abstract a single concrete implementation of *PostPublishResource (iface)
func NewPostPublishResource(id int, r resource.Resource) PostPublishedResource {
                                                         ^
tpl/internal/go_templates/texttemplate/hugo_template.go:59:37: opaque: NewExecuter function return Executer interface at the 1st result, abstract a single concrete implementation of *executer (iface)
func NewExecuter(helper ExecHelper) Executer {
                                    ^
watcher/filenotify/filenotify.go:33:48: opaque: NewPollingWatcher function return FileWatcher interface at the 1st result, abstract a single concrete implementation of *filePoller (iface)
func NewPollingWatcher(interval time.Duration) FileWatcher {
                                               ^
markup/converter/hooks/hooks.go:51:6: unused: interface ImageLinkContext is declared but not used within the package (iface)
type ImageLinkContext interface {
     ^
markup/converter/hooks/hooks.go:124:6: unused: interface PositionerSourceTargetProvider is declared but not used within the package (iface)
type PositionerSourceTargetProvider interface {
     ^
markup/converter/hooks/hooks.go:162:6: unused: interface PassthroughRenderer is declared but not used within the package (iface)
type PassthroughRenderer interface {
     ^
markup/converter/hooks/hooks.go:207:6: unused: interface ElementPositionResolver is declared but not used within the package (iface)
type ElementPositionResolver interface {
     ^
markup/converter/hooks/hooks.go:154:6: unused: interface BlockquoteRenderer is declared but not used within the package (iface)
type BlockquoteRenderer interface {
     ^
markup/converter/hooks/hooks.go:146:6: unused: interface LinkRenderer is declared but not used within the package (iface)
type LinkRenderer interface {
     ^
markup/converter/hooks/hooks.go:150:6: unused: interface CodeBlockRenderer is declared but not used within the package (iface)
type CodeBlockRenderer interface {
     ^
markup/converter/hooks/hooks.go:166:6: unused: interface IsDefaultCodeBlockRendererProvider is declared but not used within the package (iface)
type IsDefaultCodeBlockRendererProvider interface {
     ^
markup/converter/hooks/hooks.go:158:6: unused: interface TableRenderer is declared but not used within the package (iface)
type TableRenderer interface {
     ^
markup/converter/hooks/hooks.go:198:6: unused: interface HeadingRenderer is declared but not used within the package (iface)
type HeadingRenderer interface {
     ^
markup/converter/converter.go:45:6: unused: interface ProviderProvider is declared but not used within the package (iface)
type ProviderProvider interface {
     ^
markup/converter/converter.go:97:6: unused: interface ParseRenderer is declared but not used within the package (iface)
type ParseRenderer interface {
     ^
markup/converter/converter.go:114:6: unused: interface DocumentInfo is declared but not used within the package (iface)
type DocumentInfo interface {
     ^
markup/converter/converter.go:124:6: unused: interface AnchorNameSanitizer is declared but not used within the package (iface)
type AnchorNameSanitizer interface {
     ^
markup/converter/converter.go:119:6: unused: interface TableOfContentsProvider is declared but not used within the package (iface)
type TableOfContentsProvider interface {
     ^
resources/resource/resourcetypes.go:280:6: unused: interface UnmarshableResource is declared but not used within the package (iface)
type UnmarshableResource interface {
     ^
resources/resource/resourcetypes.go:125:6: unused: interface WithResourceMetaProvider is declared but not used within the package (iface)
type WithResourceMetaProvider interface {
     ^
resources/resource/resourcetypes.go:185:6: unused: interface Weight0Provider is declared but not used within the package (iface)
type Weight0Provider interface {
     ^
Command Mean [s] Min [s] Max [s] Relative
iface 2.552 ± 0.060 2.495 2.702 2.67 ± 0.07
goconst 0.956 ± 0.009 0.944 0.974 1.00
durationcheck 2.523 ± 0.020 2.482 2.554 2.64 ± 0.03

kubernetes/kubernetes

pkg/controller/volume/persistentvolume/metrics/metrics.go:57:6: identical: interface PVLister contains identical methods or type constraints from another interface, causing redundancy (iface)
type PVLister interface {
     ^
pkg/controller/volume/persistentvolume/metrics/metrics.go:62:6: identical: interface PVCLister contains identical methods or type constraints from another interface, causing redundancy (iface)
type PVCLister interface {
     ^
pkg/volume/volume.go:202:6: identical: interface BlockVolumeUnmapper contains identical methods or type constraints from another interface, causing redundancy (iface)
type BlockVolumeUnmapper interface {
     ^
pkg/volume/volume.go:42:6: identical: interface BlockVolume contains identical methods or type constraints from another interface, causing redundancy (iface)
type BlockVolume interface {
     ^
pkg/volume/volume.go:175:6: identical: interface BlockVolumeMapper contains identical methods or type constraints from another interface, causing redundancy (iface)
type BlockVolumeMapper interface {
     ^
pkg/registry/admissionregistration/resolver/resolver.go:64:73: opaque: NewDiscoveryResourceResolver function return ResourceResolver interface at the 1st result, abstract a single concrete implementation of *discoveryResourceResolver (iface)
func NewDiscoveryResourceResolver(client discovery.DiscoveryInterface) (ResourceResolver, error) {
                                                                        ^
pkg/registry/rbac/clusterrole/registry.go:42:42: opaque: NewRegistry function return Registry interface at the 1st result, abstract a single concrete implementation of *storage (iface)
func NewRegistry(s rest.StandardStorage) Registry {
                                         ^
pkg/registry/rbac/clusterrolebinding/registry.go:42:42: opaque: NewRegistry function return Registry interface at the 1st result, abstract a single concrete implementation of *storage (iface)
func NewRegistry(s rest.StandardStorage) Registry {
                                         ^
pkg/registry/rbac/role/registry.go:42:42: opaque: NewRegistry function return Registry interface at the 1st result, abstract a single concrete implementation of *storage (iface)
func NewRegistry(s rest.StandardStorage) Registry {
                                         ^
pkg/registry/rbac/rolebinding/registry.go:42:42: opaque: NewRegistry function return Registry interface at the 1st result, abstract a single concrete implementation of *storage (iface)
func NewRegistry(s rest.StandardStorage) Registry {
                                         ^
pkg/controller/podautoscaler/monitor/monitor.go:48:12: opaque: New function return Monitor interface at the 1st result, abstract a single concrete implementation of *monitor (iface)
func New() Monitor {
           ^
pkg/kubelet/status/state/state_checkpoint.go:184:31: opaque: NewNoopStateCheckpoint function return State interface at the 1st result, abstract a single concrete implementation of *noopStateCheckpoint (iface)
func NewNoopStateCheckpoint() State {
                              ^
pkg/kubelet/status/state/state_mem.go:35:23: opaque: NewStateMemory function return State interface at the 1st result, abstract a single concrete implementation of *stateMemory (iface)
func NewStateMemory() State {
                      ^
pkg/kubelet/cm/devicemanager/checkpoint/checkpoint.go:80:71: opaque: newV2 function return DeviceManagerCheckpoint interface at the 1st result, abstract a single concrete implementation of *Data (iface)
func newV2(devEntries []PodDevicesEntry, devices map[string][]string) DeviceManagerCheckpoint {
                                                                      ^
pkg/kubelet/cm/devicemanager/plugin/v1beta1/client.go:57:68: opaque: NewPluginClient function return Client interface at the 1st result, abstract a single concrete implementation of *client (iface)
func NewPluginClient(r string, socketPath string, h ClientHandler) Client {
                                                                   ^
test/utils/runners.go:1301:37: opaque: StaticPodTemplate function return PodTemplate interface at the 1st result, abstract a single concrete implementation of *staticPodTemplate (iface)
func StaticPodTemplate(pod *v1.Pod) PodTemplate {
                                    ^
pkg/volume/testing/volume_host.go:93:278: opaque: newFakeVolumeHost function return FakeVolumeHost interface at the 1st result, abstract a single concrete implementation of *fakeVolumeHost (iface)
func newFakeVolumeHost(t *testing.T, rootDir string, kubeClient clientset.Interface, plugins []VolumePlugin, pathToTypeMap map[string]hostutil.FileType, nodeName string, driverLister storagelistersv1.CSIDriverLister, volumeAttachLister storagelistersv1.VolumeAttachmentLister) FakeVolumeHost {
                                                                                                                                                                                                                                                                                     ^
pkg/volume/testing/volume_host.go:259:290: opaque: newFakeAttachDetachVolumeHost function return FakeVolumeHost interface at the 1st result, abstract a single concrete implementation of *fakeAttachDetachVolumeHost (iface)
func newFakeAttachDetachVolumeHost(t *testing.T, rootDir string, kubeClient clientset.Interface, plugins []VolumePlugin, pathToTypeMap map[string]hostutil.FileType, nodeName string, driverLister storagelistersv1.CSIDriverLister, volumeAttachLister storagelistersv1.VolumeAttachmentLister) FakeVolumeHost {
                                                                                                                                                                                                                                                                                                 ^
test/e2e/storage/drivers/csi-test/mock/cache/SnapshotCache.go:47:25: opaque: NewSnapshotCache function return SnapshotCache interface at the 1st result, abstract a single concrete implementation of *snapshotCache (iface)
func NewSnapshotCache() SnapshotCache {
                        ^
test/e2e/storage/drivers/csi-test/mock/service/service.go:140:25: opaque: New function return Service interface at the 1st result, abstract a single concrete implementation of *service (iface)
func New(config Config) Service {
                        ^
test/e2e/storage/drivers/csi.go:501:54: opaque: InitMockCSIDriver function return MockCSITestDriver interface at the 1st result, abstract a single concrete implementation of *mockCSIDriver (iface)
func InitMockCSIDriver(driverOpts CSIMockDriverOpts) MockCSITestDriver {
                                                     ^
test/e2e/storage/testsuites/capacity.go:200:44: opaque: HaveCapacitiesForClass function return CapacityMatcher interface at the 1st result, abstract a single concrete implementation of *haveCSIStorageCapacities (iface)
func HaveCapacitiesForClass(scName string) CapacityMatcher {
                                           ^
test/e2e/storage/testsuites/capacity.go:242:127: opaque: HaveCapacitiesForClassAndNodes function return CapacityMatcher interface at the 1st result, abstract a single concrete implementation of *haveLocalStorageCapacities (iface)
func HaveCapacitiesForClassAndNodes(ctx context.Context, client kubernetes.Interface, driverName, scName, topologyKey string) CapacityMatcher {
                                                                                                                              ^
test/e2e_node/remote/ssh_runner.go:58:31: opaque: NewSSHRunner function return Runner interface at the 1st result, abstract a single concrete implementation of *SSHRunner (iface)
func NewSSHRunner(cfg Config) Runner {
                              ^
cluster/images/etcd/migrate/migrate_client.go:41:49: opaque: NewEtcdMigrateClient function return EtcdMigrateClient interface at the 1st result, abstract a single concrete implementation of *CombinedEtcdClient (iface)
func NewEtcdMigrateClient(cfg *EtcdMigrateCfg) (EtcdMigrateClient, error) {
                                                ^
cmd/kubeadm/app/phases/upgrade/staticpods.go:87:138: opaque: NewKubeStaticPodPathManager function return StaticPodPathManager interface at the 1st result, abstract a single concrete implementation of *KubeStaticPodPathManager (iface)
func NewKubeStaticPodPathManager(kubernetesDir, patchesDir, tempDir, backupDir, backupEtcdDir string, keepManifestDir, keepEtcdDir bool) StaticPodPathManager {
                                                                                                                                         ^
cmd/kubeadm/app/phases/upgrade/versiongetter.go:58:55: opaque: NewKubeVersionGetter function return VersionGetter interface at the 1st result, abstract a single concrete implementation of *KubeVersionGetter (iface)
func NewKubeVersionGetter(client clientset.Interface) VersionGetter {
                                                      ^
cmd/kubeadm/app/phases/upgrade/versiongetter.go:164:75: opaque: NewOfflineVersionGetter function return VersionGetter interface at the 1st result, abstract a single concrete implementation of *OfflineVersionGetter (iface)
func NewOfflineVersionGetter(versionGetter VersionGetter, version string) VersionGetter {
                                                                          ^
cmd/kubeadm/app/util/apiclient/wait.go:74:89: opaque: NewKubeWaiter function return Waiter interface at the 1st result, abstract a single concrete implementation of *KubeWaiter (iface)
func NewKubeWaiter(client clientset.Interface, timeout time.Duration, writer io.Writer) Waiter {
                                                                                        ^
cmd/kubeadm/app/util/runtime/runtime.go:67:44: opaque: NewContainerRuntime function return ContainerRuntime interface at the 1st result, abstract a single concrete implementation of *CRIRuntime (iface)
func NewContainerRuntime(criSocket string) ContainerRuntime {
                                           ^
pkg/auth/nodeidentifier/default.go:29:33: opaque: NewDefaultNodeIdentifier function return NodeIdentifier interface at the 1st result, abstract a single concrete implementation of defaultNodeIdentifier (iface)
func NewDefaultNodeIdentifier() NodeIdentifier {
                                ^
pkg/controller/history/controller_history.go:207:90: opaque: NewHistory function return Interface interface at the 1st result, abstract a single concrete implementation of *realHistory (iface)
func NewHistory(client clientset.Interface, lister appslisters.ControllerRevisionLister) Interface {
                                                                                         ^
pkg/controller/history/controller_history.go:213:72: opaque: NewFakeHistory function return Interface interface at the 1st result, abstract a single concrete implementation of *fakeHistory (iface)
func NewFakeHistory(informer appsinformers.ControllerRevisionInformer) Interface {
                                                                       ^
pkg/controller/namespace/deletion/namespaced_resources_deleter.go:49:35: opaque: NewNamespacedResourcesDeleter function return NamespacedResourcesDeleterInterface interface at the 1st result, abstract a single concrete implementation of *namespacedResourcesDeleter (iface)
	finalizerToken v1.FinalizerName) NamespacedResourcesDeleterInterface {
	                                 ^
pkg/controller/podautoscaler/metrics/client.go:42:177: opaque: NewRESTMetricsClient function return MetricsClient interface at the 1st result, abstract a single concrete implementation of *restMetricsClient (iface)
func NewRESTMetricsClient(resourceClient resourceclient.PodMetricsesGetter, customClient customclient.CustomMetricsClient, externalClient externalclient.ExternalMetricsClient) MetricsClient {
                                                                                                                                                                                ^
pkg/controller/statefulset/stateful_set_control.go:63:39: opaque: NewDefaultStatefulSetControl function return StatefulSetControlInterface interface at the 1st result, abstract a single concrete implementation of *defaultStatefulSetControl (iface)
	controllerHistory history.Interface) StatefulSetControlInterface {
	                                     ^
pkg/controller/statefulset/stateful_set_status_updater.go:43:43: opaque: NewRealStatefulSetStatusUpdater function return StatefulSetStatusUpdaterInterface interface at the 1st result, abstract a single concrete implementation of *realStatefulSetStatusUpdater (iface)
	setLister appslisters.StatefulSetLister) StatefulSetStatusUpdaterInterface {
	                                         ^
pkg/controller/volume/attachdetach/cache/actual_state_of_world.go:187:69: opaque: NewActualStateOfWorld function return ActualStateOfWorld interface at the 1st result, abstract a single concrete implementation of *actualStateOfWorld (iface)
func NewActualStateOfWorld(volumePluginMgr *volume.VolumePluginMgr) ActualStateOfWorld {
                                                                    ^
pkg/controller/volume/attachdetach/cache/desired_state_of_world.go:127:70: opaque: NewDesiredStateOfWorld function return DesiredStateOfWorld interface at the 1st result, abstract a single concrete implementation of *desiredStateOfWorld (iface)
func NewDesiredStateOfWorld(volumePluginMgr *volume.VolumePluginMgr) DesiredStateOfWorld {
                                                                     ^
pkg/controller/volume/attachdetach/populator/desired_state_of_world_populator.go:67:60: opaque: NewDesiredStateOfWorldPopulator function return DesiredStateOfWorldPopulator interface at the 1st result, abstract a single concrete implementation of *desiredStateOfWorldPopulator (iface)
	intreeToCSITranslator csimigration.InTreeToCSITranslator) DesiredStateOfWorldPopulator {
	                                                          ^
pkg/controller/volume/attachdetach/reconciler/reconciler.go:78:33: opaque: NewReconciler function return Reconciler interface at the 1st result, abstract a single concrete implementation of *reconciler (iface)
	recorder record.EventRecorder) Reconciler {
	                               ^
pkg/controller/volume/attachdetach/statusupdater/fake_node_status_updater.go:26:49: opaque: NewFakeNodeStatusUpdater function return NodeStatusUpdater interface at the 1st result, abstract a single concrete implementation of *fakeNodeStatusUpdater (iface)
func NewFakeNodeStatusUpdater(returnError bool) NodeStatusUpdater {
                                                ^
pkg/controller/volume/attachdetach/statusupdater/node_status_updater.go:47:47: opaque: NewNodeStatusUpdater function return NodeStatusUpdater interface at the 1st result, abstract a single concrete implementation of *nodeStatusUpdater (iface)
	actualStateOfWorld cache.ActualStateOfWorld) NodeStatusUpdater {
	                                             ^
pkg/controlplane/reconcilers/instancecount.go:43:84: opaque: NewMasterCountEndpointReconciler function return EndpointReconciler interface at the 1st result, abstract a single concrete implementation of *masterCountEndpointReconciler (iface)
func NewMasterCountEndpointReconciler(masterCount int, epAdapter EndpointsAdapter) EndpointReconciler {
                                                                                   ^
pkg/controlplane/reconcilers/lease.go:158:82: opaque: NewLeaseEndpointReconciler function return EndpointReconciler interface at the 1st result, abstract a single concrete implementation of *leaseEndpointReconciler (iface)
func NewLeaseEndpointReconciler(epAdapter EndpointsAdapter, masterLeases Leases) EndpointReconciler {
                                                                                 ^
pkg/controlplane/reconcilers/none.go:31:34: opaque: NewNoneEndpointReconciler function return EndpointReconciler interface at the 1st result, abstract a single concrete implementation of *noneEndpointReconciler (iface)
func NewNoneEndpointReconciler() EndpointReconciler {
                                 ^
pkg/credentialprovider/plugins.go:50:25: opaque: NewDockerKeyring function return DockerKeyring interface at the 1st result, abstract a single concrete implementation of *providersDockerKeyring (iface)
func NewDockerKeyring() DockerKeyring {
                        ^
pkg/kubelet/pod_workers.go:606:3: opaque: newPodWorkers function return PodWorkers interface at the 1st result, abstract a single concrete implementation of *podWorkers (iface)
) PodWorkers {
  ^
pkg/kubelet/cadvisor/helpers_linux.go:61:53: opaque: NewImageFsInfoProvider function return ImageFsInfoProvider interface at the 1st result, abstract a single concrete implementation of *imageFsInfoProvider (iface)
func NewImageFsInfoProvider(runtimeEndpoint string) ImageFsInfoProvider {
                                                    ^
pkg/kubelet/checkpointmanager/checkpoint_manager_test.go:71:86: opaque: newFakeCheckpointV1 function return FakeCheckpoint interface at the 1st result, abstract a single concrete implementation of *CheckpointData (iface)
func newFakeCheckpointV1(name string, portMappings []*PortMapping, hostNetwork bool) FakeCheckpoint {
                                                                                     ^
Command Mean [s] Min [s] Max [s] Relative
iface 9.642 ± 0.096 9.516 9.767 1.73 ± 0.02
goconst 5.572 ± 0.028 5.521 5.603 1.00
durationcheck 9.537 ± 0.096 9.430 9.675 1.71 ± 0.02

go-acme/lego

challenge/provider.go:25:6: unused: interface ProviderTimeout is declared but not used within the package (iface)
type ProviderTimeout interface {
     ^
Command Mean [s] Min [s] Max [s] Relative
iface 1.897 ± 0.020 1.862 1.926 2.16 ± 0.04
goconst 0.876 ± 0.014 0.859 0.898 1.00
durationcheck 1.935 ± 0.070 1.858 2.099 2.21 ± 0.09

pact-foundation/pact-go

matchers/matcher.go:86:53: opaque: EachLike function return Matcher interface at the 1st result, abstract a single concrete implementation of eachLike (iface)
func EachLike(content interface{}, minRequired int) Matcher {
                                                    ^
matchers/matcher.go:105:32: opaque: Like function return Matcher interface at the 1st result, abstract a single concrete implementation of like (iface)
func Like(content interface{}) Matcher {
                               ^
matchers/matcher.go:115:44: opaque: Term function return Matcher interface at the 1st result, abstract a single concrete implementation of term (iface)
func Term(generate string, matcher string) Matcher {
                                           ^
matchers/matcher_v3.go:11:31: opaque: Decimal function return Matcher interface at the 1st result, abstract a single concrete implementation of like (iface)
func Decimal(example float64) Matcher {
                              ^
matchers/matcher_v3.go:20:27: opaque: Integer function return Matcher interface at the 1st result, abstract a single concrete implementation of like (iface)
func Integer(example int) Matcher {
                          ^
matchers/matcher_v3.go:63:36: opaque: Equality function return Matcher interface at the 1st result, abstract a single concrete implementation of equality (iface)
func Equality(content interface{}) Matcher {
                                   ^
matchers/matcher_v3.go:85:31: opaque: Includes function return Matcher interface at the 1st result, abstract a single concrete implementation of includes (iface)
func Includes(content string) Matcher {
                              ^
matchers/matcher_v3.go:112:52: opaque: FromProviderState function return Matcher interface at the 1st result, abstract a single concrete implementation of fromProviderState (iface)
func FromProviderState(expression, example string) Matcher {
                                                   ^
matchers/matcher_v3.go:138:52: opaque: EachKeyLike function return Matcher interface at the 1st result, abstract a single concrete implementation of eachKeyLike (iface)
func EachKeyLike(key string, template interface{}) Matcher {
                                                   ^
matchers/matcher_v3.go:161:46: opaque: ArrayContaining function return Matcher interface at the 1st result, abstract a single concrete implementation of arrayContaining (iface)
func ArrayContaining(variants []interface{}) Matcher {
                                             ^
matchers/matcher_v3.go:185:61: opaque: ArrayMinMaxLike function return Matcher interface at the 1st result, abstract a single concrete implementation of minMaxLike (iface)
func ArrayMinMaxLike(content interface{}, min int, max int) Matcher {
                                                            ^
matchers/matcher_v3.go:205:49: opaque: ArrayMaxLike function return Matcher interface at the 1st result, abstract a single concrete implementation of minMaxLike (iface)
func ArrayMaxLike(content interface{}, max int) Matcher {
                                                ^
matchers/matcher_v3.go:237:51: opaque: DateGenerated function return Matcher interface at the 1st result, abstract a single concrete implementation of stringGenerator (iface)
func DateGenerated(example string, format string) Matcher {
                                                  ^
matchers/matcher_v3.go:250:51: opaque: TimeGenerated function return Matcher interface at the 1st result, abstract a single concrete implementation of stringGenerator (iface)
func TimeGenerated(example string, format string) Matcher {
                                                  ^
matchers/matcher_v3.go:263:55: opaque: DateTimeGenerated function return Matcher interface at the 1st result, abstract a single concrete implementation of stringGenerator (iface)
func DateTimeGenerated(example string, format string) Matcher {
                                                      ^
internal/native/mock_server.go:661:6: unused: interface stringLike is declared but not used within the package (iface)
type stringLike interface {
     ^
Command Mean [ms] Min [ms] Max [ms] Relative
iface 463.1 ± 10.8 451.3 491.0 1.58 ± 0.05
goconst 293.8 ± 6.0 287.0 304.2 1.00
durationcheck 458.0 ± 9.0 449.8 480.9 1.56 ± 0.04

rclone/rclone

fs/chunkedreader/parallel.go:148:82: opaque: newParallel function return ChunkedReader interface at the 1st result, abstract a single concrete implementation of *parallel (iface)
func newParallel(ctx context.Context, o fs.Object, chunkSize int64, streams int) ChunkedReader {
                                                                                 ^
fs/chunkedreader/sequential.go:31:98: opaque: newSequential function return ChunkedReader interface at the 1st result, abstract a single concrete implementation of *sequential (iface)
func newSequential(ctx context.Context, o fs.Object, initialChunkSize int64, maxChunkSize int64) ChunkedReader {
                                                                                                 ^
lib/encoder/encoder.go:1216:17: opaque: Identity function return Encoder interface at the 1st result, abstract a single concrete implementation of identity (iface)
func Identity() Encoder {
                ^
backend/hidrive/hidrivehash/internal/internal.go:10:6: unused: interface LevelHash is declared but not used within the package (iface)
type LevelHash interface {
     ^
fs/types.go:238:6: unused: interface FullObject is declared but not used within the package (iface)
type FullObject interface {
     ^
fs/types.go:172:6: unused: interface ParentIDer is declared but not used within the package (iface)
type ParentIDer interface {
     ^
fs/features.go:667:6: unused: interface RangeSeeker is declared but not used within the package (iface)
type RangeSeeker interface {
     ^
Command Mean [s] Min [s] Max [s] Relative
iface 2.260 ± 0.075 2.203 2.418 1.82 ± 0.06
goconst 1.243 ± 0.012 1.233 1.264 1.00
durationcheck 2.210 ± 0.028 2.173 2.256 1.78 ± 0.03

hashicorp/terraform

internal/collections/unique_key.go:55:42: opaque: cmpUniqueKeyFunc function return UniqueKey[T] interface at the 1st result, abstract a single concrete implementation of cmpUniqueKey[T] (iface)
func cmpUniqueKeyFunc[T comparable](v T) UniqueKey[T] {
                                         ^
internal/command/clistate/state.go:85:63: opaque: NewLocker function return Locker interface at the 1st result, abstract a single concrete implementation of *locker (iface)
func NewLocker(timeout time.Duration, view views.StateLocker) Locker {
                                                              ^
internal/command/clistate/state.go:173:22: opaque: NewNoopLocker function return Locker interface at the 1st result, abstract a single concrete implementation of noopLocker (iface)
func NewNoopLocker() Locker {
                     ^
internal/command/jsonformat/structured/attribute_path/matcher.go:50:53: opaque: Parse function return Matcher interface at the 1st result, abstract a single concrete implementation of *PathMatcher (iface)
func Parse(message json.RawMessage, propagate bool) Matcher {
                                                    ^
internal/command/jsonformat/structured/attribute_path/matcher.go:212:22: opaque: AlwaysMatcher function return Matcher interface at the 1st result, abstract a single concrete implementation of *alwaysMatcher (iface)
func AlwaysMatcher() Matcher {
                     ^
internal/command/views/operation.go:39:73: opaque: NewOperation function return Operation interface at the 1st result, abstract a single concrete implementation of *OperationHuman (iface)
func NewOperation(vt arguments.ViewType, inAutomation bool, view *View) Operation {
                                                                        ^
internal/command/views/json/hook.go:42:103: opaque: NewApplyStart function return Hook interface at the 1st result, abstract a single concrete implementation of *applyStart (iface)
func NewApplyStart(addr addrs.AbsResourceInstance, action plans.Action, idKey string, idValue string) Hook {
                                                                                                      ^
internal/command/views/json/hook.go:74:99: opaque: NewApplyProgress function return Hook interface at the 1st result, abstract a single concrete implementation of *applyProgress (iface)
func NewApplyProgress(addr addrs.AbsResourceInstance, action plans.Action, elapsed time.Duration) Hook {
                                                                                                  ^
internal/command/views/json/hook.go:109:122: opaque: NewApplyComplete function return Hook interface at the 1st result, abstract a single concrete implementation of *applyComplete (iface)
func NewApplyComplete(addr addrs.AbsResourceInstance, action plans.Action, idKey, idValue string, elapsed time.Duration) Hook {
                                                                                                                         ^
internal/command/views/json/hook.go:141:98: opaque: NewApplyErrored function return Hook interface at the 1st result, abstract a single concrete implementation of *applyErrored (iface)
func NewApplyErrored(addr addrs.AbsResourceInstance, action plans.Action, elapsed time.Duration) Hook {
                                                                                                 ^
internal/command/views/json/hook.go:167:76: opaque: NewProvisionStart function return Hook interface at the 1st result, abstract a single concrete implementation of *provisionStart (iface)
func NewProvisionStart(addr addrs.AbsResourceInstance, provisioner string) Hook {
                                                                           ^
internal/command/views/json/hook.go:191:94: opaque: NewProvisionProgress function return Hook interface at the 1st result, abstract a single concrete implementation of *provisionProgress (iface)
func NewProvisionProgress(addr addrs.AbsResourceInstance, provisioner string, output string) Hook {
                                                                                             ^
internal/command/views/json/hook.go:215:79: opaque: NewProvisionComplete function return Hook interface at the 1st result, abstract a single concrete implementation of *provisionComplete (iface)
func NewProvisionComplete(addr addrs.AbsResourceInstance, provisioner string) Hook {
                                                                              ^
internal/command/views/json/hook.go:239:78: opaque: NewProvisionErrored function return Hook interface at the 1st result, abstract a single concrete implementation of *provisionErrored (iface)
func NewProvisionErrored(addr addrs.AbsResourceInstance, provisioner string) Hook {
                                                                             ^
internal/command/views/json/hook.go:267:77: opaque: NewRefreshStart function return Hook interface at the 1st result, abstract a single concrete implementation of *refreshStart (iface)
func NewRefreshStart(addr addrs.AbsResourceInstance, idKey, idValue string) Hook {
                                                                            ^
internal/command/views/json/hook.go:296:80: opaque: NewRefreshComplete function return Hook interface at the 1st result, abstract a single concrete implementation of *refreshComplete (iface)
func NewRefreshComplete(addr addrs.AbsResourceInstance, idKey, idValue string) Hook {
                                                                               ^
internal/command/webbrowser/native.go:13:26: opaque: NewNativeLauncher function return Launcher interface at the 1st result, abstract a single concrete implementation of nativeLauncher (iface)
func NewNativeLauncher() Launcher {
                         ^
internal/dag/edge.go:16:39: opaque: BasicEdge function return Edge interface at the 1st result, abstract a single concrete implementation of *basicEdge (iface)
func BasicEdge(source, target Vertex) Edge {
                                      ^
internal/getproviders/package_authentication.go:178:64: opaque: PackageAuthenticationAll function return PackageAuthentication interface at the 1st result, abstract a single concrete implementation of packageAuthenticationAll (iface)
func PackageAuthenticationAll(checks ...PackageAuthentication) PackageAuthentication {
                                                               ^
internal/getproviders/package_authentication.go:226:74: opaque: NewPackageHashAuthentication function return PackageAuthentication interface at the 1st result, abstract a single concrete implementation of packageHashAuthentication (iface)
func NewPackageHashAuthentication(platform Platform, validHashes []Hash) PackageAuthentication {
                                                                         ^
internal/getproviders/package_authentication.go:290:91: opaque: NewArchiveChecksumAuthentication function return PackageAuthentication interface at the 1st result, abstract a single concrete implementation of archiveHashAuthentication (iface)
func NewArchiveChecksumAuthentication(platform Platform, wantSHA256Sum [sha256.Size]byte) PackageAuthentication {
                                                                                          ^
internal/getproviders/package_authentication.go:333:107: opaque: NewMatchingChecksumAuthentication function return PackageAuthentication interface at the 1st result, abstract a single concrete implementation of matchingChecksumAuthentication (iface)
func NewMatchingChecksumAuthentication(document []byte, filename string, wantSHA256Sum [sha256.Size]byte) PackageAuthentication {
                                                                                                          ^
internal/getproviders/package_authentication.go:395:80: opaque: NewSignatureAuthentication function return PackageAuthentication interface at the 1st result, abstract a single concrete implementation of signatureAuthentication (iface)
func NewSignatureAuthentication(document, signature []byte, keys []SigningKey) PackageAuthentication {
                                                                               ^
internal/plugin/discovery/get_cache.go:24:38: opaque: NewLocalPluginCache function return PluginCache interface at the 1st result, abstract a single concrete implementation of *pluginCache (iface)
func NewLocalPluginCache(dir string) PluginCache {
                                     ^
internal/states/statemgr/statemgr_fake.go:32:54: opaque: NewFullFake function return Full interface at the 1st result, abstract a single concrete implementation of *fakeFull (iface)
func NewFullFake(t Transient, initial *states.State) Full {
                                                     ^
internal/states/statemgr/statemgr_fake.go:115:61: opaque: NewUnlockErrorFull function return Full interface at the 1st result, abstract a single concrete implementation of *fakeErrorFull (iface)
func NewUnlockErrorFull(t Transient, initial *states.State) Full {
                                                            ^
internal/states/statemgr/transient_inmem.go:18:50: opaque: NewTransientInMemory function return Transient interface at the 1st result, abstract a single concrete implementation of *transientInMemory (iface)
func NewTransientInMemory(initial *states.State) Transient {
                                                 ^
internal/terraform/node_resource_partial_plan.go:364:47: opaque: DynamicTransformer function return GraphTransformer interface at the 1st result, abstract a single concrete implementation of *transformDynamic (iface)
func DynamicTransformer(f func(*Graph) error) GraphTransformer {
                                              ^
internal/terraform/transform.go:53:50: opaque: GraphTransformMulti function return GraphTransformer interface at the 1st result, abstract a single concrete implementation of *graphTransformerMulti (iface)
func GraphTransformMulti(ts ...GraphTransformer) GraphTransformer {
                                                 ^
internal/terraform/transform_destroy_edge_test.go:563:41: opaque: testDestroyNode function return GraphNodeDestroyer interface at the 1st result, abstract a single concrete implementation of *NodeDestroyResourceInstance (iface)
func testDestroyNode(addrString string) GraphNodeDestroyer {
                                        ^
internal/terraform/transform_destroy_edge_test.go:569:40: opaque: testUpdateNode function return GraphNodeCreator interface at the 1st result, abstract a single concrete implementation of *NodeApplyableResourceInstance (iface)
func testUpdateNode(addrString string) GraphNodeCreator {
                                       ^
internal/tfdiags/contextual.go:78:83: opaque: AttributeValue function return Diagnostic interface at the 1st result, abstract a single concrete implementation of *attributeDiagnostic (iface)
func AttributeValue(severity Severity, summary, detail string, attrPath cty.Path) Diagnostic {
                                                                                  ^
internal/tfdiags/contextual.go:352:69: opaque: WholeContainingBody function return Diagnostic interface at the 1st result, abstract a single concrete implementation of *wholeBodyDiagnostic (iface)
func WholeContainingBody(severity Severity, summary, detail string) Diagnostic {
                                                                    ^
internal/tfdiags/override.go:28:98: opaque: Override function return Diagnostic interface at the 1st result, abstract a single concrete implementation of overriddenDiagnostic (iface)
func Override(original Diagnostic, severity Severity, createExtra func() DiagnosticExtraWrapper) Diagnostic {
                                                                                                 ^
internal/tfdiags/rpc_friendly.go:24:43: opaque: makeRPCFriendlyDiag function return Diagnostic interface at the 1st result, abstract a single concrete implementation of *rpcFriendlyDiag (iface)
func makeRPCFriendlyDiag(diag Diagnostic) Diagnostic {
                                          ^
internal/tfdiags/simple_warning.go:11:32: opaque: SimpleWarning function return Diagnostic interface at the 1st result, abstract a single concrete implementation of simpleWarning (iface)
func SimpleWarning(msg string) Diagnostic {
                               ^
internal/tfdiags/sourceless.go:10:60: opaque: Sourceless function return Diagnostic interface at the 1st result, abstract a single concrete implementation of diagnosticBase (iface)
func Sourceless(severity Severity, summary, detail string) Diagnostic {
                                                           ^
internal/backend/backendrun/operation.go:37:6: unused: interface OperationsBackend is declared but not used within the package (iface)
type OperationsBackend interface {
     ^
internal/backend/backendrun/local_run.go:22:6: unused: interface Local is declared but not used within the package (iface)
type Local interface {
     ^
internal/cloudplugin/interface.go:10:6: unused: interface Cloud1 is declared but not used within the package (iface)
type Cloud1 interface {
     ^
internal/moduletest/suite.go:14:6: unused: interface TestSuiteRunner is declared but not used within the package (iface)
type TestSuiteRunner interface {
     ^
internal/states/statemgr/persistent.go:147:6: unused: interface IntermediateStateConditionalPersister is declared but not used within the package (iface)
type IntermediateStateConditionalPersister interface {
     ^
Command Mean [s] Min [s] Max [s] Relative
iface 3.130 ± 0.078 3.067 3.335 1.97 ± 0.05
goconst 1.589 ± 0.012 1.568 1.605 1.00
durationcheck 3.067 ± 0.033 3.018 3.130 1.93 ± 0.03

traefik/traefik

pkg/api/sort.go:344:6: identical: interface orderedByName contains identical methods or type constraints from another interface, causing redundancy (iface)
type orderedByName interface {
     ^
pkg/api/sort.go:20:6: identical: interface orderedWithName contains identical methods or type constraints from another interface, causing redundancy (iface)
type orderedWithName interface {
     ^
pkg/metrics/datadog.go:52:66: opaque: RegisterDatadog function return Registry interface at the 1st result, abstract a single concrete implementation of *standardRegistry (iface)
func RegisterDatadog(ctx context.Context, config *types.Datadog) Registry {
                                                                 ^
pkg/metrics/metrics.go:68:46: opaque: NewMultiRegistry function return Registry interface at the 1st result, abstract a single concrete implementation of *standardRegistry (iface)
func NewMultiRegistry(registries []Registry) Registry {
                                             ^
pkg/metrics/prometheus.go:107:53: opaque: initStandardRegistry function return Registry interface at the 1st result, abstract a single concrete implementation of *standardRegistry (iface)
func initStandardRegistry(config *types.Prometheus) Registry {
                                                    ^
pkg/metrics/statsd.go:48:64: opaque: RegisterStatsd function return Registry interface at the 1st result, abstract a single concrete implementation of *standardRegistry (iface)
func RegisterStatsd(ctx context.Context, config *types.Statsd) Registry {
                                                               ^
pkg/metrics/metrics_test.go:69:34: opaque: newCollectingRetryMetrics function return Registry interface at the 1st result, abstract a single concrete implementation of *standardRegistry (iface)
func newCollectingRetryMetrics() Registry {
                                 ^
pkg/server/service/service_test.go:549:18: opaque: newRtMock function return RoundTripperGetter interface at the 1st result, abstract a single concrete implementation of *rtMock (iface)
func newRtMock() RoundTripperGetter {
                 ^
pkg/middlewares/stateful.go:7:6: unused: interface Stateful is declared but not used within the package (iface)
type Stateful interface {
     ^
pkg/provider/provider.go:9:6: unused: interface Provider is declared but not used within the package (iface)
type Provider interface {
     ^
pkg/healthcheck/healthcheck.go:35:6: unused: interface StatusUpdater is declared but not used within the package (iface)
type StatusUpdater interface {
     ^
pkg/ip/strategy.go:14:6: unused: interface Strategy is declared but not used within the package (iface)
type Strategy interface {
     ^
pkg/provider/kubernetes/gateway/kubernetes.go:107:6: unused: interface ExtensionBuilderRegistry is declared but not used within the package (iface)
type ExtensionBuilderRegistry interface {
     ^
pkg/provider/kubernetes/k8s/router_transform.go:10:6: unused: interface RouterTransform is declared but not used within the package (iface)
type RouterTransform interface {
     ^
pkg/types/route_appender.go:8:6: unused: interface RouteAppender is declared but not used within the package (iface)
type RouteAppender interface {
     ^
Command Mean [s] Min [s] Max [s] Relative
iface 3.107 ± 0.100 2.962 3.323 2.69 ± 0.10
goconst 1.155 ± 0.023 1.128 1.196 1.00
durationcheck 3.027 ± 0.040 2.955 3.073 2.62 ± 0.06

You can find the workflow here:
https://github.com/ldez/golangci-lint-bench/actions/runs/10931896392

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
bench-new-linter
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@ldez