handle constant expressions via typechecker

Author: kalexmills

.github/workflows/golangci-compat.yml

@@ -0,0 +1,27 @@
+name: GolangCI-Lint Compatibility
+
+on:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+  schedule:
+    - cron: "0 0 * * 0" # Run weekly on Sundays at midnight
+
+jobs:
+  test-golangci-compat:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.21"
+          check-latest: true
+
+      - name: Make script executable
+        run: chmod +x ./scripts/test-golangci-compat.sh
+
+      - name: Run compatibility tests
+        run: ./scripts/test-golangci-compat.sh

api.go

@@ -3,6 +3,7 @@ package goconst
 import (
 	"go/ast"
 	"go/token"
+	"go/types"
 	"sort"
 	"strings"
 	"sync"
@@ -46,8 +47,8 @@ func PutIssueBuffer(issues []Issue) {
 
 // Config contains all configuration options for the goconst analyzer.
 type Config struct {
-	// IgnoreStrings is a regular expression to filter strings
-	IgnoreStrings string
+	// IgnoreStrings is a list of regular expressions to filter strings
+	IgnoreStrings []string
 	// IgnoreTests indicates whether test files should be excluded
 	IgnoreTests bool
 	// MatchWithConstants enables matching strings with existing constants
@@ -68,11 +69,51 @@ type Config struct {
 	FindDuplicates bool
 }
 
-// Run analyzes the provided AST files for duplicated strings or numbers
-// according to the provided configuration.
-// It returns a slice of Issue objects containing the findings.
-func Run(files []*ast.File, fset *token.FileSet, cfg *Config) ([]Issue, error) {
-	p := New(
+// NewWithIgnorePatterns creates a new instance of the parser with support for multiple ignore patterns.
+// This is an alternative constructor that takes a slice of ignore string patterns.
+func NewWithIgnorePatterns(
+	path, ignore string,
+	ignoreStrings []string,
+	ignoreTests, matchConstant, numbers, findDuplicates bool,
+	numberMin, numberMax, minLength, minOccurrences int,
+	excludeTypes map[Type]bool) *Parser {
+
+	// Join multiple patterns with OR for regex
+	var ignoreStringsPattern string
+	if len(ignoreStrings) > 0 {
+		if len(ignoreStrings) > 1 {
+			// Wrap each pattern in parentheses and join with OR
+			patterns := make([]string, len(ignoreStrings))
+			for i, pattern := range ignoreStrings {
+				patterns[i] = "(" + pattern + ")"
+			}
+			ignoreStringsPattern = strings.Join(patterns, "|")
+		} else {
+			// Single pattern case
+			ignoreStringsPattern = ignoreStrings[0]
+		}
+	}
+
+	return New(
+		path,
+		ignore,
+		ignoreStringsPattern,
+		ignoreTests,
+		matchConstant,
+		numbers,
+		findDuplicates,
+		numberMin,
+		numberMax,
+		minLength,
+		minOccurrences,
+		excludeTypes,
+	)
+}
+
+// RunWithConfig is a convenience function that runs the analysis with a Config object
+// directly supporting multiple ignore patterns.
+func RunWithConfig(files []*ast.File, fset *token.FileSet, typeInfo *types.Info, cfg *Config) ([]Issue, error) {
+	p := NewWithIgnorePatterns(
 		"",
 		"",
 		cfg.IgnoreStrings,
@@ -136,9 +177,9 @@ func Run(files []*ast.File, fset *token.FileSet, cfg *Config) ([]Issue, error) {
 			ast.Walk(&treeVisitor{
 				fileSet:     fset,
 				packageName: emptyStr,
-				fileName:    emptyStr,
 				p:           p,
 				ignoreRegex: p.ignoreStringsRegex,
+				typeInfo:    typeInfo,
 			}, f)
 		}(f)
 	}
@@ -233,3 +274,10 @@ func Run(files []*ast.File, fset *token.FileSet, cfg *Config) ([]Issue, error) {
 	// Don't return the buffer to pool as the caller now owns it
 	return issueBuffer, nil
 }
+
+// Run analyzes the provided AST files for duplicated strings or numbers
+// according to the provided configuration.
+// It returns a slice of Issue objects containing the findings.
+func Run(files []*ast.File, fset *token.FileSet, typeInfo *types.Info, cfg *Config) ([]Issue, error) {
+	return RunWithConfig(files, fset, typeInfo, cfg)
+}

api_test.go

@@ -4,6 +4,7 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
+	"go/types"
 	"testing"
 )
 
@@ -47,6 +48,19 @@ func example() {
 const ConstA = "test"
 func example() {
 	const ConstB = "test"
+}`,
+			config: &Config{
+				FindDuplicates: true,
+			},
+			expectedIssues: 1,
+		},
+		{
+			name: "duplicate computed consts",
+			code: `package example
+const ConstA = "te"
+const Test = "test"
+func example() {
+	const ConstB = ConstA + "st"
 }`,
 			config: &Config{
 				FindDuplicates: true,
@@ -65,7 +79,7 @@ func example() {
 			config: &Config{
 				MinStringLength: 3,
 				MinOccurrences:  2,
-				IgnoreStrings:   "test",
+				IgnoreStrings:   []string{"test"},
 			},
 			expectedIssues: 1, // Only "another" should be reported
 		},
@@ -164,7 +178,10 @@ func example() {
 				t.Fatalf("Failed to parse test code: %v", err)
 			}
 
-			issues, err := Run([]*ast.File{f}, fset, tt.config)
+			chkr, info := checker(fset)
+			_ = chkr.Files([]*ast.File{f})
+
+			issues, err := Run([]*ast.File{f}, fset, info, tt.config)
 			if err != nil {
 				t.Fatalf("Run() error = %v", err)
 			}
@@ -201,7 +218,10 @@ func example() {
 		MatchWithConstants: true,
 	}
 
-	issues, err := Run([]*ast.File{f}, fset, config)
+	chkr, info := checker(fset)
+	_ = chkr.Files([]*ast.File{f})
+
+	issues, err := Run([]*ast.File{f}, fset, info, config)
 	if err != nil {
 		t.Fatalf("Run() error = %v", err)
 	}
@@ -256,16 +276,16 @@ func example2() {
 			expectedOccurrenceCount: 3,
 		},
 		{
-			name: "duplicate consts in different packages",
-			code1: `package package1
+			name: "duplicate consts in different files",
+			code1: `package example
 const ConstA = "shared"
 const ConstB = "shared"
 `,
-			code2: `package package2
+			code2: `package example
 const (
 	ConstC = "shared"
 	ConstD = "shared"
-	ConstE= "unique"
+	ConstE = "unique"
 )`,
 			config: &Config{
 				FindDuplicates: true,
@@ -290,7 +310,10 @@ const (
 				t.Fatalf("Failed to parse test code: %v", err)
 			}
 
-			issues, err := Run([]*ast.File{f1, f2}, fset, tt.config)
+			chkr, info := checker(fset)
+			_ = chkr.Files([]*ast.File{f1, f2})
+
+			issues, err := Run([]*ast.File{f1, f2}, fset, info, tt.config)
 			if err != nil {
 				t.Fatalf("Run() error = %v", err)
 			}
@@ -348,8 +371,10 @@ func allContexts(param string) string {
 		MinStringLength: 3,
 		MinOccurrences:  2,
 	}
+	chkr, info := checker(fset)
+	_ = chkr.Files([]*ast.File{f})
 
-	issues, err := Run([]*ast.File{f}, fset, config)
+	issues, err := Run([]*ast.File{f}, fset, info, config)
 	if err != nil {
 		t.Fatalf("Run() error = %v", err)
 	}
@@ -429,8 +454,10 @@ func multipleContexts() {
 				MinOccurrences:  2,
 				ExcludeTypes:    tt.excludeTypes,
 			}
+			chkr, info := checker(fset)
+			_ = chkr.Files([]*ast.File{f})
 
-			issues, err := Run([]*ast.File{f}, fset, config)
+			issues, err := Run([]*ast.File{f}, fset, info, config)
 			if err != nil {
 				t.Fatalf("Run() error = %v", err)
 			}
@@ -453,3 +480,13 @@ func multipleContexts() {
 		})
 	}
 }
+
+func checker(fset *token.FileSet) (*types.Checker, *types.Info) {
+	cfg := &types.Config{
+		Error: func(err error) {},
+	}
+	info := &types.Info{
+		Types: make(map[ast.Expr]types.TypeAndValue),
+	}
+	return types.NewChecker(cfg, fset, types.NewPackage("", "example"), info), info
+}

benchmarks_test.go

@@ -41,7 +41,6 @@ func BenchmarkParseSampleFile(b *testing.B) {
 			p:           p,
 			fileSet:     fset,
 			packageName: "testdata",
-			fileName:    "testdata/sample.go",
 		}
 
 		ast.Walk(v, f)
@@ -62,9 +61,13 @@ func BenchmarkRun(b *testing.B) {
 		MatchWithConstants: true,
 	}
 
+	chkr, info := checker(fset)
+	_ = chkr.Files([]*ast.File{f})
+
 	b.ResetTimer()
+
 	for i := 0; i < b.N; i++ {
-		_, err := Run([]*ast.File{f}, fset, config)
+		_, err := Run([]*ast.File{f}, fset, info, config)
 		if err != nil {
 			b.Fatalf("Run() error = %v", err)
 		}

cmd/goconst/main.go

@@ -45,7 +45,7 @@ Examples:
 
 var (
 	flagIgnore         = flag.String("ignore", "", "ignore files matching the given regular expression")
-	flagIgnoreStrings  = flag.String("ignore-strings", "", "ignore strings matching the given regular expression")
+	flagIgnoreStrings  = flag.String("ignore-strings", "", "ignore strings matching the given regular expressions (comma separated)")
 	flagIgnoreTests    = flag.Bool("ignore-tests", true, "exclude tests from the search")
 	flagMinOccurrences = flag.Int("min-occurrences", 2, "report from how many occurrences")
 	flagMinLength      = flag.Int("min-length", 3, "only report strings with the minimum given length")
@@ -93,10 +93,17 @@ func main() {
 // run analyzes a single path for repeated strings that could be constants.
 // It returns true if any issues were found, and an error if the analysis failed.
 func run(path string) (bool, error) {
-	gco := goconst.New(
+	// Parse ignore strings - handling comma-separated values
+	var ignoreStrings []string
+	if *flagIgnoreStrings != "" {
+		// Split by commas but handle escaping
+		ignoreStrings = parseCommaSeparatedValues(*flagIgnoreStrings)
+	}
+
+	gco := goconst.NewWithIgnorePatterns(
 		path,
 		*flagIgnore,
-		*flagIgnoreStrings,
+		ignoreStrings,
 		*flagIgnoreTests,
 		*flagMatchConstant,
 		*flagNumbers,
@@ -115,6 +122,50 @@ func run(path string) (bool, error) {
 	return printOutput(strs, consts, *flagOutput)
 }
 
+// parseCommaSeparatedValues splits a comma-separated string into a slice of strings,
+// handling escaping of commas within values.
+func parseCommaSeparatedValues(input string) []string {
+	if input == "" {
+		return nil
+	}
+
+	// Simple case - no escaping needed
+	if !strings.Contains(input, "\\,") {
+		return strings.Split(input, ",")
+	}
+
+	// Handle escaped commas
+	var result []string
+	var current strings.Builder
+	escaped := false
+
+	for _, char := range input {
+		if escaped {
+			if char == ',' {
+				current.WriteRune(',')
+			} else {
+				current.WriteRune('\\')
+				current.WriteRune(char)
+			}
+			escaped = false
+		} else if char == '\\' {
+			escaped = true
+		} else if char == ',' {
+			result = append(result, current.String())
+			current.Reset()
+		} else {
+			current.WriteRune(char)
+		}
+	}
+
+	// Don't forget the last value
+	if current.Len() > 0 {
+		result = append(result, current.String())
+	}
+
+	return result
+}
+
 // usage prints the usage documentation to the specified writer.
 func usage(out io.Writer) {
 	if _, err := fmt.Fprint(out, usageDoc); err != nil {