ability to ignore specific types through new -ignore-enum-types flag

This commit adds an -ignore-enum-types flag to the analyzer. The value
is a regexp pattern that specifies types that should be ignored in
exhaustiveness checks. The new flag is similar to the existing
-ignore-enum-members flag, except that the new flag is used to ignore
types, not constants.

Also: update and clarify related documentation. Re-add the "Skip
analysis" section that was removed in earlier commits.

Related test files are added to testdata/src/ignore-pattern/, which is a
rename of the previously named ignore-enum-member directory.

Author: Nishanth Shanmugham

common.go

@@ -1,6 +1,7 @@
 package exhaustive
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
 	"go/types"
@@ -140,13 +141,25 @@ type typeAndMembers struct {
 }
 
 type checklist struct {
-	info     map[enumType]enumMembers
-	checkl   map[member]struct{}
-	ignoreRx *regexp.Regexp
+	info             map[enumType]enumMembers
+	checkl           map[member]struct{}
+	ignoreConstantRe *regexp.Regexp
+	ignoreTypeRe     *regexp.Regexp
 }
 
-func (c *checklist) ignore(pattern *regexp.Regexp) {
-	c.ignoreRx = pattern
+func (c *checklist) ignoreConstant(pattern *regexp.Regexp) {
+	c.ignoreConstantRe = pattern
+}
+
+func (c *checklist) ignoreType(pattern *regexp.Regexp) {
+	c.ignoreTypeRe = pattern
+}
+
+func (*checklist) reMatch(re *regexp.Regexp, s string) bool {
+	if re == nil {
+		return false
+	}
+	return re.MatchString(s)
 }
 
 func (c *checklist) add(et enumType, em enumMembers, includeUnexported bool) {
@@ -162,7 +175,10 @@ func (c *checklist) add(et enumType, em enumMembers, includeUnexported bool) {
 		if !ast.IsExported(name) && !includeUnexported {
 			return
 		}
-		if c.ignoreRx != nil && c.ignoreRx.MatchString(et.Pkg().Path()+"."+name) {
+		if c.reMatch(c.ignoreConstantRe, fmt.Sprintf("%s.%s", et.Pkg().Path(), name)) {
+			return
+		}
+		if c.reMatch(c.ignoreTypeRe, fmt.Sprintf("%s.%s", et.Pkg().Path(), et.TypeName.Name())) {
 			return
 		}
 		mem := member{
@@ -262,22 +278,6 @@ func diagnosticEnumType(enumType *types.TypeName) string {
 	return enumType.Pkg().Name() + "." + enumType.Name()
 }
 
-func dedupEnumTypes(types []enumType) []enumType {
-	// TODO(nishanths) this function is a candidate for type parameterization
-
-	m := make(map[enumType]struct{})
-	var ret []enumType
-	for _, t := range types {
-		_, ok := m[t]
-		if ok {
-			continue
-		}
-		m[t] = struct{}{}
-		ret = append(ret, t)
-	}
-	return ret
-}
-
 func diagnosticEnumTypes(types []enumType) string {
 	var buf strings.Builder
 	for i := range types {
@@ -308,6 +308,30 @@ func diagnosticGroups(gs []group) string {
 	return strings.Join(out, ", ")
 }
 
+func toEnumTypes(es []typeAndMembers) []enumType {
+	out := make([]enumType, len(es))
+	for i := range es {
+		out[i] = es[i].et
+	}
+	return out
+}
+
+func dedupEnumTypes(types []enumType) []enumType {
+	// TODO(nishanths) this function is a candidate for type parameterization
+
+	m := make(map[enumType]struct{})
+	var ret []enumType
+	for _, t := range types {
+		_, ok := m[t]
+		if ok {
+			continue
+		}
+		m[t] = struct{}{}
+		ret = append(ret, t)
+	}
+	return ret
+}
+
 // TODO(nishanths) If dropping pre-go1.18 support, the following
 // types and functions are candidates to be type parameterized.
 

common_test.go

@@ -115,8 +115,8 @@ func TestChecklist(t *testing.T) {
 		})
 	})
 
-	t.Run("ignore regexp", func(t *testing.T) {
-		t.Run("no filtering", func(t *testing.T) {
+	t.Run("ignore pattern", func(t *testing.T) {
+		t.Run("none", func(t *testing.T) {
 			var c checklist
 			c.add(et, em, false)
 			checkRemaining(t, c, map[string]struct{}{
@@ -130,39 +130,65 @@ func TestChecklist(t *testing.T) {
 			})
 		})
 
-		t.Run("basic", func(t *testing.T) {
-			var c checklist
-			c.ignore(regexp.MustCompile(`^github.com/example/bar-go.G$`))
-			c.add(et, em, false)
-			checkRemaining(t, c, map[string]struct{}{
-				"A": {},
-				"B": {},
-				"C": {},
-				"D": {},
-				"E": {},
-				"F": {},
+		t.Run("constant", func(t *testing.T) {
+			t.Run("basic", func(t *testing.T) {
+				var c checklist
+				c.ignoreConstant(regexp.MustCompile(`^github.com/example/bar-go.G$`))
+				c.add(et, em, false)
+				checkRemaining(t, c, map[string]struct{}{
+					"A": {},
+					"B": {},
+					"C": {},
+					"D": {},
+					"E": {},
+					"F": {},
+				})
 			})
-		})
 
-		t.Run("matches multiple", func(t *testing.T) {
-			var c checklist
-			c.ignore(regexp.MustCompile(`^github.com/example/bar-go`))
-			c.add(et, em, false)
-			checkRemaining(t, c, map[string]struct{}{})
+			t.Run("matches multiple", func(t *testing.T) {
+				var c checklist
+				c.ignoreConstant(regexp.MustCompile(`^github.com/example/bar-go`))
+				c.add(et, em, false)
+				checkRemaining(t, c, map[string]struct{}{})
+			})
+
+			t.Run("uses package path, not package name", func(t *testing.T) {
+				var c checklist
+				c.ignoreConstant(regexp.MustCompile(`bar.G`)) // this should not cause anything to be ignored.
+				c.add(et, em, false)
+				checkRemaining(t, c, map[string]struct{}{
+					"A": {},
+					"B": {},
+					"C": {},
+					"D": {},
+					"E": {},
+					"F": {},
+					"G": {},
+				})
+			})
 		})
 
-		t.Run("uses package path, not package name", func(t *testing.T) {
-			var c checklist
-			c.ignore(regexp.MustCompile(`bar.G`))
-			c.add(et, em, false)
-			checkRemaining(t, c, map[string]struct{}{
-				"A": {},
-				"B": {},
-				"C": {},
-				"D": {},
-				"E": {},
-				"F": {},
-				"G": {},
+		t.Run("type", func(t *testing.T) {
+			t.Run("basic", func(t *testing.T) {
+				var c checklist
+				c.ignoreType(regexp.MustCompile(`^github.com/example/bar-go.T$`))
+				c.add(et, em, false)
+				checkRemaining(t, c, map[string]struct{}{})
+			})
+
+			t.Run("uses package path, not package name", func(t *testing.T) {
+				var c checklist
+				c.ignoreType(regexp.MustCompile(`bar.T`)) // this should not cause anything to be ignored.
+				c.add(et, em, false)
+				checkRemaining(t, c, map[string]struct{}{
+					"A": {},
+					"B": {},
+					"C": {},
+					"D": {},
+					"E": {},
+					"F": {},
+					"G": {},
+				})
 			})
 		})
 	})

exhaustive.go

@@ -134,6 +134,7 @@ optional.
 	-check-generated               bool                     false
 	-default-signifies-exhaustive  bool                     false
 	-ignore-enum-members           regexp pattern           (none)
+	-ignore-enum-types             regexp pattern           (none)
 	-package-scope-only            bool                     false
 
 The -check flag specifies is a comma-separated list of program elements
@@ -145,14 +146,7 @@ If the -explicit-exhaustive-switch flag is enabled, the analyzer checks a
 switch statement only if it associated with a comment beginning with
 "//exhaustive:enforce". By default the flag is disabled, which means that the
 analyzer checks every enum switch statement not associated with a comment
-beginning with "//exhaustive:ignore". As an example, the following switch
-statement will be ignored.
-
-	//exhaustive:ignore
-	switch v {
-	case A:
-	case B:
-	}
+beginning with "//exhaustive:ignore".
 
 The -explicit-exhaustive-map flag is the map literal counterpart of the
 -explicit-exhaustive-switch flag.
@@ -169,21 +163,39 @@ If the -default-signifies-exhaustive flag is enabled, the presence of a
 to counter the purpose of exhaustiveness checking, so it is not recommended
 that you do so.
 
-The -ignore-enum-members flag specifies a regular expression in Go
-package regexp syntax. Enum members matching the regular expression do
-not have to be listed in switch statement cases or map literals to
-satisfy exhaustiveness. The specified regular expression is matched
-against an enum member name inclusive of the enum package import path.
-For example, if the enum package import path is "example.com/eco" and
-the member name is "Tundra", the specified regular expression will be
-matched against the string "example.com/eco.Tundra".
+The -ignore-enum-members flag specifies a regular expression in Go package
+regexp syntax. Constants matching the regular expression do not have to be
+listed in switch statement cases or map literals in order to satisfy
+exhaustiveness. The specified regular expression is matched against an the
+constant name inclusive of the enum package import path. For example, if the
+package import path of the constant is "example.com/eco" and the constant name
+is "Tundra", the specified regular expression will be matched against the
+string "example.com/eco.Tundra".
+
+The -ignore-enum-types flag is similar to the -ignore-enum-members flag,
+except that it applies to types.
 
 If the -package-scope-only flag is enabled, the analyzer only finds enums
 defined in package scope, but not in inner scopes such as functions.
 Consequently only switch statements and map literals that use these enums will
 be checked for exhaustiveness. By default, the analyzer finds enums defined in
 all scopes, including in inner scopes such as functions.
 
+# Skip analysis
+
+To skip analysis of a switch statement or map literal, associate it with a
+comment that begins with "//exhaustive:ignore". For example:
+
+	//exhaustive:ignore
+	switch v {
+	case A:
+	case B:
+	}
+
+To ignore specific constants for exhaustiveness checks, use the
+-ignore-enum-members flag. To ignore specific types, use the
+-ignore-enum-types flag.
+
 [Go language spec]: https://golang.org/ref/spec
 */
 package exhaustive
@@ -203,7 +215,8 @@ func init() {
 	Analyzer.Flags.BoolVar(&fExplicitExhaustiveMap, ExplicitExhaustiveMapFlag, false, `check map literal only if associated with "//exhaustive:enforce" comment`)
 	Analyzer.Flags.BoolVar(&fCheckGenerated, CheckGeneratedFlag, false, "check generated files")
 	Analyzer.Flags.BoolVar(&fDefaultSignifiesExhaustive, DefaultSignifiesExhaustiveFlag, false, "presence of 'default' case in switch statement unconditionally satisfies exhaustiveness")
-	Analyzer.Flags.Var(&fIgnoreEnumMembers, IgnoreEnumMembersFlag, "enum members matching `regexp` do not have to be listed to satisfy exhaustiveness")
+	Analyzer.Flags.Var(&fIgnoreEnumMembers, IgnoreEnumMembersFlag, "constants matching `regexp` are ignored for exhaustiveness checks")
+	Analyzer.Flags.Var(&fIgnoreEnumTypes, IgnoreEnumTypesFlag, "types matching `regexp` are ignored for exhaustiveness checks")
 	Analyzer.Flags.BoolVar(&fPackageScopeOnly, PackageScopeOnlyFlag, false, "find enums only in package scopes, not inner scopes")
 
 	var unused string
@@ -220,6 +233,7 @@ const (
 	CheckGeneratedFlag             = "check-generated"
 	DefaultSignifiesExhaustiveFlag = "default-signifies-exhaustive"
 	IgnoreEnumMembersFlag          = "ignore-enum-members"
+	IgnoreEnumTypesFlag            = "ignore-enum-types"
 	PackageScopeOnlyFlag           = "package-scope-only"
 
 	IgnorePatternFlag    = "ignore-pattern"    // Deprecated: use IgnoreEnumMembersFlag.
@@ -257,6 +271,7 @@ var (
 	fCheckGenerated             bool
 	fDefaultSignifiesExhaustive bool
 	fIgnoreEnumMembers          regexpFlag
+	fIgnoreEnumTypes            regexpFlag
 	fPackageScopeOnly           bool
 )
 
@@ -269,6 +284,7 @@ func resetFlags() {
 	fCheckGenerated = false
 	fDefaultSignifiesExhaustive = false
 	fIgnoreEnumMembers = regexpFlag{}
+	fIgnoreEnumTypes = regexpFlag{}
 	fPackageScopeOnly = false
 }
 
@@ -298,12 +314,14 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		explicit:                   fExplicitExhaustiveSwitch,
 		defaultSignifiesExhaustive: fDefaultSignifiesExhaustive,
 		checkGenerated:             fCheckGenerated,
-		ignoreEnumMembers:          fIgnoreEnumMembers.rx,
+		ignoreConstant:             fIgnoreEnumMembers.re,
+		ignoreType:                 fIgnoreEnumTypes.re,
 	}
 	mapConf := mapConfig{
-		explicit:          fExplicitExhaustiveMap,
-		checkGenerated:    fCheckGenerated,
-		ignoreEnumMembers: fIgnoreEnumMembers.rx,
+		explicit:       fExplicitExhaustiveMap,
+		checkGenerated: fCheckGenerated,
+		ignoreConstant: fIgnoreEnumMembers.re,
+		ignoreType:     fIgnoreEnumTypes.re,
 	}
 	swChecker := switchChecker(pass, swConf, generated, comments)
 	mapChecker := mapChecker(pass, mapConf, generated, comments)

exhaustive_test.go

@@ -40,10 +40,14 @@ func TestExhaustive(t *testing.T) {
 	runTest(t, "default-signifies-exhaustive/default-absent/...", func() { fDefaultSignifiesExhaustive = true })
 	runTest(t, "default-signifies-exhaustive/default-present/...", func() { fDefaultSignifiesExhaustive = true })
 
-	// Tests for the -ignore-enum-member flag.
-	runTest(t, "ignore-enum-member/...", func() {
-		re := regexp.MustCompile(`_UNSPECIFIED$|^general/y\.Echinodermata$|^ignore-enum-member.User$`)
-		fIgnoreEnumMembers = regexpFlag{re}
+	// Tests for -ignore-enum-members and -ignore-enum-types flags.
+	runTest(t, "ignore-pattern/...", func() {
+		fIgnoreEnumMembers = regexpFlag{
+			regexp.MustCompile(`_UNSPECIFIED$|^general/y\.Echinodermata$|^ignore-pattern.User$`),
+		}
+		fIgnoreEnumTypes = regexpFlag{
+			regexp.MustCompile(`label|^reflect.Kind$|^time.Duration$`),
+		}
 	})
 
 	// Tests for -package-scope-only flag.

flag.go

@@ -11,27 +11,27 @@ var _ flag.Value = (*stringsFlag)(nil)
 
 // regexpFlag implements flag.Value for parsing
 // regular expression flag inputs.
-type regexpFlag struct{ rx *regexp.Regexp }
+type regexpFlag struct{ re *regexp.Regexp }
 
 func (f *regexpFlag) String() string {
-	if f == nil || f.rx == nil {
+	if f == nil || f.re == nil {
 		return ""
 	}
-	return f.rx.String()
+	return f.re.String()
 }
 
 func (f *regexpFlag) Set(expr string) error {
 	if expr == "" {
-		f.rx = nil
+		f.re = nil
 		return nil
 	}
 
-	rx, err := regexp.Compile(expr)
+	re, err := regexp.Compile(expr)
 	if err != nil {
 		return err
 	}
 
-	f.rx = rx
+	f.re = re
 	return nil
 }