Prepare linter for golangci-lint (#5)

# golangci/golangci-lint#4196
1. TestdataDir() -> analysistest.TestData()
2. Described False-Negative cases as testcases and in README.md
3. Fixed link for type_nested.go.skip in README.md
4. Added testcase with generic
5. Added testcase with alias
6. Added testcase with map, chan, array, func
# golangci/golangci-lint#4196
7. Added glob syntax for pkgs
8. Renamed options
9. Extended unexpected code message
10. Added unimplemented testcases

README.md

@@ -18,8 +18,8 @@ Installation
 
 ### Options
 
-- `-b`, `--blockedPkgs` - list of packages, where the structures should be created by factories. By default, all structures in all packages should be created by factories, [tests](testdata/src/factory/blockedPkgs).
- - `-ob`, `onlyBlockedPkgs` - only blocked packages should use factory to initiate struct, [tests](testdata/src/factory/onlyBlockedPkgs).
+- `--packageGlobs` - list of glob packages, which can create structures without factories inside the glob package. By default, all structures from another package should be created by factories, [tests](testdata/src/factory/packageGlobs).
+ - `onlyPackageGlobs` - use a factory to initiate a structure for glob packages only, [tests](testdata/src/factory/onlyPackageGlobs).
 
 ## Example
 
@@ -120,8 +120,28 @@ func nextID() int64 {
 </td></tr>
 </tbody></table>
 
+## False Negative
+
+Linter doesn't catch some cases.
+
+1. Buffered channel. You can initialize struct in line `v, ok := <-bufCh` [example](testdata/src/factory/unimplemented/chan.go).
+2. Local initialization, [example](testdata/src/factory/unimplemented/local/).
+3. Named return. If you want to block that case, you can use [nonamedreturns](https://github.com/firefart/nonamedreturns) linter, [example](testdata/src/factory/unimplemented/named_return.go).
+4. var declaration, `var initilized nested.Struct` gives structure without factory, [example](testdata/src/factory/unimplemented/var.go).
+5. Casting to nested struct, [example](testdata/src/factory/unimplemented/casting/).
+
 ## TODO
 
+### Possible Features
+
+1. Catch nested struct in the same package, [example](testdata/src/factory/unimplemented/local/nested_struct.go).
+ ```go
+ return Struct{
+ Other: OtherStruct{}, // want `Use factory for nested.Struct`
+ }
+ ```
+2. Resolve false negative issue with `var declaration`.
+
 ### Features that are difficult to implement and unplanned
 
-1. Type assertion, type declaration and type underlying, [tests](testdata/src/factory/default/type_nested.go.skip).
+1. Type assertion, type declaration and type underlying, [tests](testdata/src/factory/simple/type_nested.go.skip).

factory.go

@@ -4,15 +4,17 @@ import (
  "fmt"
  "go/ast"
  "go/types"
+ "log/slog"
  "strings"
 
+ "github.com/gobwas/glob"
  "golang.org/x/tools/go/analysis"
  "golang.org/x/tools/go/analysis/passes/inspect"
 )
 
 type config struct {
- blockedPkgs stringsFlag
- onlyBlockedPkgs bool
+ pkgGlobs stringsFlag
+ onlyPkgGlobs bool
 }
 
 type stringsFlag []string
@@ -28,21 +30,18 @@ func (s *stringsFlag) Set(value string) error {
 }
 
 func (s stringsFlag) Value() []string {
- blockedPkgs := make([]string, 0, len(s))
+ res := make([]string, 0, len(s))
 
- for _, pgk := range s {
- pgk = strings.TrimSpace(pgk)
- pgk = strings.TrimSuffix(pgk, "/") + "/"
-
- blockedPkgs = append(blockedPkgs, pgk)
+ for _, str := range s {
+ res = append(res, strings.TrimSpace(str))
  }
 
- return blockedPkgs
+ return res
 }
 
 const (
- blockedPkgsDesc = "List of packages, which should use factory to initiate struct."
- onlyBlockedPkgsDesc = "Only blocked packages should use factory to initiate struct."
+ packageGlobsDesc = "List of glob packages, which can create structures without factories inside the glob package"
+ onlyPkgGlobsDesc = "Use a factory to initiate a structure for glob packages only."
 )
 
 func NewAnalyzer() *analysis.Analyzer {
@@ -54,11 +53,9 @@ func NewAnalyzer() *analysis.Analyzer {
 
  cfg := config{}
 
- analyzer.Flags.Var(&cfg.blockedPkgs, "b", blockedPkgsDesc)
- analyzer.Flags.Var(&cfg.blockedPkgs, "blockedPkgs", blockedPkgsDesc)
+ analyzer.Flags.Var(&cfg.pkgGlobs, "packageGlobs", packageGlobsDesc)
 
- analyzer.Flags.BoolVar(&cfg.onlyBlockedPkgs, "ob", false, onlyBlockedPkgsDesc)
- analyzer.Flags.BoolVar(&cfg.onlyBlockedPkgs, "onlyBlockedPkgs", false, onlyBlockedPkgsDesc)
+ analyzer.Flags.BoolVar(&cfg.onlyPkgGlobs, "onlyPackageGlobs", false, onlyPkgGlobsDesc)
 
  analyzer.Run = run(&cfg)
 
@@ -68,14 +65,19 @@ func NewAnalyzer() *analysis.Analyzer {
 func run(cfg *config) func(pass *analysis.Pass) (interface{}, error) {
  return func(pass *analysis.Pass) (interface{}, error) {
  var blockedStrategy blockedStrategy = newAnotherPkg()
- if len(cfg.blockedPkgs) > 0 {
+ if len(cfg.pkgGlobs) > 0 {
  defaultStrategy := blockedStrategy
- if cfg.onlyBlockedPkgs {
+ if cfg.onlyPkgGlobs {
  defaultStrategy = newNilPkg()
  }
 
+ pkgGlobs, err := compileGlobs(cfg.pkgGlobs.Value())
+ if err != nil {
+ return nil, err
+ }
+
  blockedStrategy = newBlockedPkgs(
- cfg.blockedPkgs.Value(),
+ pkgGlobs,
  defaultStrategy,
  )
  }
@@ -109,134 +111,146 @@ func (v *visitor) Visit(node ast.Node) ast.Visitor {
  return v
  }
 
- var selExpr *ast.SelectorExpr
+ compLitType := compLit.Type
 
  // check []*Struct{{},&Struct}
- arr, isArr := compLit.Type.(*ast.ArrayType)
- if isArr && len(compLit.Elts) > 0 {
- v.checkSlice(arr, compLit)
+ slice, isMap := compLitType.(*ast.ArrayType)
+ if isMap && len(compLit.Elts) > 0 {
+ v.checkSlice(slice, compLit)
 
  return v
  }
 
- ident, ok := compLit.Type.(*ast.Ident)
- if !ok {
- selExpr, ok = compLit.Type.(*ast.SelectorExpr)
- if !ok {
- return v
- }
+ // check map[Struct]Struct{{}:{}}
+ mp, isMap := compLitType.(*ast.MapType)
+ if isMap {
+ v.checkMap(mp, compLit)
 
- ident = selExpr.Sel
+ return v
  }
 
+ // check Struct{}
+ ident := v.getIdent(compLitType)
  identObj := v.pass.TypesInfo.ObjectOf(ident)
+
  if identObj == nil {
  return v
  }
 
  if v.blockedStrategy.IsBlocked(v.pass.Pkg, identObj) {
- v.report(node, identObj)
+ v.report(ident, identObj)
  }
 
  return v
 }
 
-func (v *visitor) checkSlice(arr *ast.ArrayType, compLit *ast.CompositeLit) {
- arrElt := arr.Elt
- if starExpr, ok := arr.Elt.(*ast.StarExpr); ok {
- arrElt = starExpr.X
+func (v *visitor) getIdent(expr ast.Expr) *ast.Ident {
+ // pointer *Struct{}
+ if starExpr, ok := expr.(*ast.StarExpr); ok {
+ expr = starExpr.X
  }
 
- selExpr, ok := arrElt.(*ast.SelectorExpr)
- if !ok {
- return
+ // generic Struct[any]{}
+ indexExpr, ok := expr.(*ast.IndexExpr)
+ if ok {
+ expr = indexExpr.X
  }
 
- identObj := v.pass.TypesInfo.ObjectOf(selExpr.Sel)
- if identObj != nil {
- for _, elt := range compLit.Elts {
- eltCompLit, ok := elt.(*ast.CompositeLit)
- if ok && eltCompLit.Type == nil {
- if v.blockedStrategy.IsBlocked(v.pass.Pkg, identObj) {
- v.report(elt, identObj)
- }
- }
- }
+ selExpr, ok := expr.(*ast.SelectorExpr)
+ if !ok {
+ return nil
  }
-}
 
-func (v *visitor) report(node ast.Node, obj types.Object) {
- v.pass.Reportf(
- node.Pos(),
- fmt.Sprintf(`Use factory for %s.%s`, obj.Pkg().Name(), obj.Name()),
- )
+ return selExpr.Sel
 }
 
-type blockedStrategy interface {
- IsBlocked(currentPkg *types.Package, identObj types.Object) bool
-}
+func (v *visitor) checkSlice(arr *ast.ArrayType, compLit *ast.CompositeLit) {
+ ident := v.getIdent(arr.Elt)
+ identObj := v.pass.TypesInfo.ObjectOf(ident)
 
-type nilPkg struct{}
+ if identObj == nil {
+ return
+ }
 
-func newNilPkg() nilPkg {
- return nilPkg{}
+ for _, elt := range compLit.Elts {
+ v.checkBrackets(elt, identObj)
+ }
 }
 
-func (nilPkg) IsBlocked(_ *types.Package, _ types.Object) bool {
- return false
-}
+func (v *visitor) checkMap(mp *ast.MapType, compLit *ast.CompositeLit) {
+ keyIdent := v.getIdent(mp.Key)
+ keyIdentObj := v.pass.TypesInfo.ObjectOf(keyIdent)
 
-type anotherPkg struct{}
+ valueIdent := v.getIdent(mp.Value)
+ valueIdentObj := v.pass.TypesInfo.ObjectOf(valueIdent)
 
-func newAnotherPkg() anotherPkg {
- return anotherPkg{}
-}
+ if keyIdentObj == nil && valueIdentObj == nil {
+  return
+ }
 
-func (anotherPkg) IsBlocked(
- currentPkg *types.Package,
- identObj types.Object,
-) bool {
- return currentPkg.Path() != identObj.Pkg().Path()
-}
+ for _, elt := range compLit.Elts {
+ keyValueExpr, ok := elt.(*ast.KeyValueExpr)
+ if !ok {
+ v.unexpectedCode(elt)
 
-type blockedPkgs struct {
- blockedPkgs []string
- defaultStrategy blockedStrategy
-}
+ continue
+ }
 
-func newBlockedPkgs(
- pkgs []string,
- defaultStrategy blockedStrategy,
-) blockedPkgs {
- return blockedPkgs{
- blockedPkgs: pkgs,
- defaultStrategy: defaultStrategy,
+ v.checkBrackets(keyValueExpr.Key, keyIdentObj)
+ v.checkBrackets(keyValueExpr.Value, valueIdentObj)
  }
 }
 
-func (b blockedPkgs) IsBlocked(
- currentPkg *types.Package,
- identObj types.Object,
-) bool {
- identPkgPath := identObj.Pkg().Path() + "/"
- currentPkgPath := currentPkg.Path() + "/"
+// checkBrackets check {} in array, slice, map.
+func (v *visitor) checkBrackets(expr ast.Expr, identObj types.Object) {
+ compLit, ok := expr.(*ast.CompositeLit)
+ if ok && compLit.Type == nil && identObj != nil {
+ if v.blockedStrategy.IsBlocked(v.pass.Pkg, identObj) {
+ v.report(compLit, identObj)
+ }
+ }
+}
 
- for _, blockedPkg := range b.blockedPkgs {
- isBlocked := strings.HasPrefix(identPkgPath, blockedPkg)
- isIncludedInBlocked := strings.HasPrefix(currentPkgPath, blockedPkg)
+func (v *visitor) report(node ast.Node, obj types.Object) {
+ v.pass.Reportf(
+ node.Pos(),
+ fmt.Sprintf(`Use factory for %s.%s`, obj.Pkg().Name(), obj.Name()),
+ )
+}
 
- if isIncludedInBlocked {
- continue
- }
+func (v *visitor) unexpectedCode(node ast.Node) {
+ fset := v.pass.Fset
+ pos := fset.Position(node.Pos())
+ slog.Error(
+ fmt.Sprintf("Unexpected code in %s:%d:%d, please report to the developer with example.",
+ fset.File(node.Pos()).Name(),
+ pos.Line,
+ pos.Column,
+ ),
+ )
+}
 
- if isBlocked {
+func containsMatchGlob(globs []glob.Glob, el string) bool {
+ for _, g := range globs {
+ if g.Match(el) {
  return true
  }
+ }
 
- if b.defaultStrategy.IsBlocked(currentPkg, identObj) {
- return true
+ return false
+}
+
+func compileGlobs(globs []string) ([]glob.Glob, error) {
+ compiledGlobs := make([]glob.Glob, len(globs))
+
+ for idx, globString := range globs {
+ glob, err := glob.Compile(globString)
+ if err != nil {
+ return nil, fmt.Errorf("unable to compile globs %s: %w", glob, err)
  }
+
+ compiledGlobs[idx] = glob
  }
 
- return false
+ return compiledGlobs, nil
 }

go.mod

@@ -2,7 +2,10 @@ module github.com/maranqz/go-factory-lint
 
 go 1.20
 
-require golang.org/x/tools v0.15.0
+require (
+ github.com/gobwas/glob v0.2.3
+ golang.org/x/tools v0.15.0
+)
 
 require (
  golang.org/x/mod v0.14.0 // indirect

go.sum

@@ -1,3 +1,5 @@
+github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
+github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0=
 golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE=