review

.golangci.next.reference.yml

@@ -1223,15 +1223,16 @@ linters-settings:
     var-require-grouping: true
 
   iface:
-    # By default set to empty. Leave it empty means all analyzers are enabled.
+    # By default, set to empty.
+    # Empty means that all analyzers are enabled.
     # Default: []
     enable:
       - unused
       - identical
       - opaque
     settings:
       unused:
-        # Comma-separated list of packages to exclude from the check.
+        # List of packages path to exclude from the check.
         # Default: []
         exclude:
           - github.com/example/log

jsonschema/golangci.next.jsonschema.json

@@ -1928,6 +1928,17 @@
               "items": {
                 "$ref": "#/definitions/iface-analyzers"
               }
+            },
+            "settings": {
+              "type": "object",
+              "propertyNames": {
+                "$ref": "#/definitions/iface-analyzers"
+              },
+              "patternProperties": {
+                "^.*$": {
+                  "type": "object"
+                }
+              }
             }
           }
         },

pkg/config/linters_settings.go

@@ -650,7 +650,8 @@ type GrouperSettings struct {
 }
 
 type IfaceSettings struct {
-	Enable []string `mapstructure:"enable"`
+	Enable   []string                  `mapstructure:"enable"`
+	Settings map[string]map[string]any `mapstructure:"settings"`
 }
 
 type ImportAsSettings struct {

pkg/golinters/iface/iface.go

@@ -2,73 +2,59 @@ package iface
 
 import (
 	"slices"
+	"strings"
 
 	"github.com/uudashr/iface/identical"
 	"github.com/uudashr/iface/opaque"
 	"github.com/uudashr/iface/unused"
+	"golang.org/x/exp/maps"
 	"golang.org/x/tools/go/analysis"
 
 	"github.com/golangci/golangci-lint/pkg/config"
 	"github.com/golangci/golangci-lint/pkg/goanalysis"
 )
 
-var allAnalyzers = []*analysis.Analyzer{
-	unused.Analyzer,
-	identical.Analyzer,
-	opaque.Analyzer,
-}
-
 func New(settings *config.IfaceSettings) *goanalysis.Linter {
 	var conf map[string]map[string]any
-
-	analyzers := analyzersFromSettings(settings)
+	if settings != nil {
+		conf = settings.Settings
+	}
 
 	return goanalysis.NewLinter(
 		"iface",
 		"Detect the incorrect use of interfaces, helping developers avoid interface pollution.",
-		analyzers,
+		analyzersFromSettings(settings),
 		conf,
 	).WithLoadMode(goanalysis.LoadModeTypesInfo)
 }
 
 func analyzersFromSettings(settings *config.IfaceSettings) []*analysis.Analyzer {
-	if settings == nil || len(settings.Enable) == 0 {
-		return allAnalyzers
+	allAnalyzers := map[string]*analysis.Analyzer{
+		"unused":    unused.Analyzer,
+		"identical": identical.Analyzer,
+		"opaque":    opaque.Analyzer,
 	}
 
-	enabledNames := uniqueNames(settings.Enable)
-
-	var analyzers []*analysis.Analyzer
+	if settings == nil || len(settings.Enable) == 0 {
+		analyzers := maps.Values(allAnalyzers)
 
-	for _, a := range allAnalyzers {
-		found := slices.ContainsFunc(enabledNames, func(name string) bool {
-			return name == a.Name
+		// To have a deterministic order.
+		slices.SortFunc(analyzers, func(a *analysis.Analyzer, b *analysis.Analyzer) int {
+			return strings.Compare(a.Name, b.Name)
 		})
 
-		if !found {
-			continue
-		}
+		return analyzers
+	}
 
-		analyzers = append(analyzers, a)
+	var analyzers []*analysis.Analyzer
+	for _, name := range uniqueNames(settings.Enable) {
+		analyzers = append(analyzers, allAnalyzers[name])
 	}
 
 	return analyzers
 }
 
 func uniqueNames(names []string) []string {
-	if len(names) == 0 {
-		return nil
-	}
-
-	namesMap := map[string]struct{}{}
-	for _, name := range names {
-		namesMap[name] = struct{}{}
-	}
-
-	uniqueNames := make([]string, 0, len(namesMap))
-
-	for name := range namesMap {
-		uniqueNames = append(uniqueNames, name)
-	}
-	return uniqueNames
+	slices.Sort(names)
+	return slices.Compact(names)
 }

pkg/golinters/iface/testdata/iface.go

@@ -0,0 +1,64 @@
+//golangcitest:args -Eiface
+package testdata
+
+// identical
+
+type Pinger interface { // want "identical: interface Pinger contains identical methods or type constraints from another interface, causing redundancy"
+	Ping() error
+}
+
+type Healthcheck interface { // want "identical: interface Healthcheck contains identical methods or type constraints from another interface, causing redundancy"
+	Ping() error
+}
+
+// opaque
+
+type Server interface {
+	Serve() error
+}
+
+type server struct {
+	addr string
+}
+
+func (s server) Serve() error {
+	return nil
+}
+
+func NewServer(addr string) Server { // want "opaque: NewServer function return Server interface at the 1st result, abstract a single concrete implementation of \\*server"
+	return &server{addr: addr}
+}
+
+// unused
+
+type User struct {
+	ID   string
+	Name string
+}
+
+type UserRepository interface { // want "unused: interface UserRepository is declared but not used within the package"
+	UserOf(id string) (*User, error)
+}
+
+type UserRepositorySQL struct {
+}
+
+func (r *UserRepositorySQL) UserOf(id string) (*User, error) {
+	return nil, nil
+}
+
+type Granter interface {
+	Grant(permission string) error
+}
+
+func AllowAll(g Granter) error {
+	return g.Grant("all")
+}
+
+type Allower interface {
+	Allow(permission string) error
+}
+
+func Allow(x interface{}) {
+	_ = x.(Allower)
+}

pkg/golinters/iface/testdata/iface_identical.go

@@ -0,0 +1,65 @@
+//golangcitest:args -Eiface
+//golangcitest:config_path testdata/iface_identical.yml
+package testdata
+
+// identical
+
+type Pinger interface { // want "identical: interface Pinger contains identical methods or type constraints from another interface, causing redundancy"
+	Ping() error
+}
+
+type Healthcheck interface { // want "identical: interface Healthcheck contains identical methods or type constraints from another interface, causing redundancy"
+	Ping() error
+}
+
+// opaque
+
+type Server interface {
+	Serve() error
+}
+
+type server struct {
+	addr string
+}
+
+func (s server) Serve() error {
+	return nil
+}
+
+func NewServer(addr string) Server {
+	return &server{addr: addr}
+}
+
+// unused
+
+type User struct {
+	ID   string
+	Name string
+}
+
+type UserRepository interface {
+	UserOf(id string) (*User, error)
+}
+
+type UserRepositorySQL struct {
+}
+
+func (r *UserRepositorySQL) UserOf(id string) (*User, error) {
+	return nil, nil
+}
+
+type Granter interface {
+	Grant(permission string) error
+}
+
+func AllowAll(g Granter) error {
+	return g.Grant("all")
+}
+
+type Allower interface {
+	Allow(permission string) error
+}
+
+func Allow(x interface{}) {
+	_ = x.(Allower)
+}