Integrate inspector helper into linters

Author: JoelSpeed

pkg/analysis/commentstart/analyzer.go

@@ -8,16 +8,15 @@ import (
 	"strings"
 
 	"github.com/JoelSpeed/kal/pkg/analysis/helpers/extractjsontags"
+	"github.com/JoelSpeed/kal/pkg/analysis/helpers/inspector"
+	"github.com/JoelSpeed/kal/pkg/analysis/helpers/markers"
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/analysis/passes/inspect"
-	"golang.org/x/tools/go/ast/inspector"
 )
 
 const name = "commentstart"
 
 var (
 	errCouldNotGetInspector = errors.New("could not get inspector")
-	errCouldNotGetJSONTags  = errors.New("could not get json tags")
 )
 
 // Analyzer is the analyzer for the commentstart package.
@@ -26,79 +25,37 @@ var Analyzer = &analysis.Analyzer{
 	Name:     name,
 	Doc:      "Check that all struct fields in an API have a godoc, and that the godoc starts with the serialised field name",
 	Run:      run,
-	Requires: []*analysis.Analyzer{inspect.Analyzer, extractjsontags.Analyzer},
+	Requires: []*analysis.Analyzer{inspector.Analyzer},
 }
 
 func run(pass *analysis.Pass) (interface{}, error) {
-	inspect, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+	inspect, ok := pass.ResultOf[inspector.Analyzer].(inspector.Inspector)
 	if !ok {
 		return nil, errCouldNotGetInspector
 	}
 
-	jsonTags, ok := pass.ResultOf[extractjsontags.Analyzer].(extractjsontags.StructFieldTags)
-	if !ok {
-		return nil, errCouldNotGetJSONTags
-	}
-
-	// Filter to structs so that we can iterate over fields in a struct.
-	nodeFilter := []ast.Node{
-		(*ast.Field)(nil),
-	}
-
-	inspect.WithStack(nodeFilter, func(n ast.Node, push bool, stack []ast.Node) (proceed bool) {
-		if !push {
-			return false
-		}
-
-		if len(stack) < 2 {
-			return true
-		}
-
-		// The 0th node in the stack is the *ast.File.
-		// The 1st node in the stack is the *ast.GenDecl.
-		decl, ok := stack[1].(*ast.GenDecl)
-		if !ok {
-			return false
-		}
-
-		if decl.Tok != token.TYPE {
-			// Returning false here means we won't inspect non-type declarations (e.g. var, const, import).
-			return false
-		}
-
-		field, ok := n.(*ast.Field)
-		if !ok {
-			return true
-		}
-
-		return checkField(pass, field, jsonTags)
+	inspect.InspectFields(func(field *ast.Field, stack []ast.Node, jsonTagInfo extractjsontags.FieldTagInfo, markersAccess markers.Markers) {
+		checkField(pass, field, jsonTagInfo)
 	})
 
 	return nil, nil //nolint:nilnil
 }
 
-func checkField(pass *analysis.Pass, field *ast.Field, jsonTags extractjsontags.StructFieldTags) (proceed bool) {
-	if field == nil || len(field.Names) == 0 {
-		// Returning false here means we don't inspect inline fields.
-		// Types of inline fields will be inspected on its declaration.
-		return false
-	}
-
-	tagInfo := jsonTags.FieldTags(field)
-	if tagInfo.Ignored {
-		// Returning false here means we won't inspect the children of an ignored field.
-		return false
-	}
-
+func checkField(pass *analysis.Pass, field *ast.Field, tagInfo extractjsontags.FieldTagInfo) {
 	if tagInfo.Name == "" {
-		return true
+		return
 	}
 
-	fieldName := field.Names[0].Name
+	var fieldName string
+	if len(field.Names) > 0 {
+		fieldName = field.Names[0].Name
+	} else if ident, ok := field.Type.(*ast.Ident); ok {
+		fieldName = ident.Name
+	}
 
 	if field.Doc == nil {
 		pass.Reportf(field.Pos(), "field %s is missing godoc comment", fieldName)
-		return true
+		return
 	}
 
 	firstLine := field.Doc.List[0]
@@ -125,6 +82,4 @@ func checkField(pass *analysis.Pass, field *ast.Field, jsonTags extractjsontags.
 			pass.Reportf(field.Doc.List[0].Pos(), "godoc for field %s should start with '%s ...'", fieldName, tagInfo.Name)
 		}
 	}
-
-	return true
 }

pkg/analysis/commentstart/testdata/src/a/a.go

@@ -22,6 +22,8 @@ type CommentStartTestStruct struct {
 
 	StructForInlineField `json:",inline"`
 
+	A `json:"a"` // want "field A is missing godoc comment"
+
 	// IncorrectStartComment is a field with an incorrect start to the comment. // want "godoc for field IncorrectStartComment should start with 'incorrectStartComment ...'"
 	IncorrectStartComment string `json:"incorrectStartComment"`
 
@@ -53,6 +55,10 @@ type StructForInlineField struct {
 	NoComment string `json:"noComment"` // want "field NoComment is missing godoc comment"
 }
 
+type A struct {
+	NoComment string `json:"noComment"` // want "field NoComment is missing godoc comment"
+}
+
 type unexportedStruct struct {
 	NoComment string `json:"noComment"` // want "field NoComment is missing godoc comment"
 }
@@ -71,3 +77,7 @@ func FunctionWithStructs() {
 		NoComment string `json:"noComment"`
 	}
 }
+
+type Interface interface {
+	InaccessibleFunction() string
+}

pkg/analysis/commentstart/testdata/src/a/a.go.golden

@@ -22,6 +22,8 @@ type CommentStartTestStruct struct {
 
 	StructForInlineField `json:",inline"`
 
+	A `json:"a"` // want "field A is missing godoc comment"
+
 	// incorrectStartComment is a field with an incorrect start to the comment. // want "godoc for field IncorrectStartComment should start with 'incorrectStartComment ...'"
 	IncorrectStartComment string `json:"incorrectStartComment"`
 
@@ -53,6 +55,10 @@ type StructForInlineField struct {
 	NoComment string `json:"noComment"` // want "field NoComment is missing godoc comment"
 }
 
+type A struct {
+	NoComment string `json:"noComment"` // want "field NoComment is missing godoc comment"
+}
+
 type unexportedStruct struct {
 	NoComment string `json:"noComment"` // want "field NoComment is missing godoc comment"
 }
@@ -71,3 +77,7 @@ func FunctionWithStructs() {
 		NoComment string `json:"noComment"`
 	}
 }
+
+type Interface interface {
+	InaccessibleFunction() string
+}

pkg/analysis/jsontags/analyzer.go

@@ -4,15 +4,14 @@ import (
 	"errors"
 	"fmt"
 	"go/ast"
-	"go/token"
 	"regexp"
 
 	"github.com/JoelSpeed/kal/pkg/analysis/helpers/extractjsontags"
+	"github.com/JoelSpeed/kal/pkg/analysis/helpers/inspector"
+	"github.com/JoelSpeed/kal/pkg/analysis/helpers/markers"
 	"github.com/JoelSpeed/kal/pkg/config"
 
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/analysis/passes/inspect"
-	"golang.org/x/tools/go/ast/inspector"
 )
 
 const (
@@ -24,7 +23,6 @@ const (
 
 var (
 	errCouldNotGetInspector = errors.New("could not get inspector")
-	errCouldNotGetJSONTags  = errors.New("could not get json tags")
 )
 
 type analyzer struct {
@@ -48,61 +46,24 @@ func newAnalyzer(cfg config.JSONTagsConfig) (*analysis.Analyzer, error) {
 		Name:     name,
 		Doc:      "Check that all struct fields in an API are tagged with json tags",
 		Run:      a.run,
-		Requires: []*analysis.Analyzer{inspect.Analyzer, extractjsontags.Analyzer},
+		Requires: []*analysis.Analyzer{inspector.Analyzer},
 	}, nil
 }
 
 func (a *analyzer) run(pass *analysis.Pass) (interface{}, error) {
-	inspect, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+	inspect, ok := pass.ResultOf[inspector.Analyzer].(inspector.Inspector)
 	if !ok {
 		return nil, errCouldNotGetInspector
 	}
 
-	jsonTags, ok := pass.ResultOf[extractjsontags.Analyzer].(extractjsontags.StructFieldTags)
-	if !ok {
-		return nil, errCouldNotGetJSONTags
-	}
-
-	// Filter to fields so that we can iterate over fields in a struct.
-	nodeFilter := []ast.Node{
-		(*ast.Field)(nil),
-	}
-
-	inspect.WithStack(nodeFilter, func(n ast.Node, push bool, stack []ast.Node) (proceed bool) {
-		if !push {
-			return false
-		}
-
-		if len(stack) < 2 {
-			return true
-		}
-
-		// The 0th node in the stack is the *ast.File.
-		// The 1st node in the stack is the *ast.GenDecl.
-		decl, ok := stack[1].(*ast.GenDecl)
-		if !ok {
-			return false
-		}
-
-		if decl.Tok != token.TYPE {
-			// Returning false here means we won't inspect non-type declarations (e.g. var, const, import).
-			return false
-		}
-
-		field, ok := n.(*ast.Field)
-		if !ok {
-			return true
-		}
-
-		return a.checkField(pass, field, jsonTags)
+	inspect.InspectFields(func(field *ast.Field, stack []ast.Node, jsonTagInfo extractjsontags.FieldTagInfo, markersAccess markers.Markers) {
+		a.checkField(pass, field, jsonTagInfo)
 	})
 
 	return nil, nil //nolint:nilnil
 }
 
-func (a *analyzer) checkField(pass *analysis.Pass, field *ast.Field, jsonTags extractjsontags.StructFieldTags) (proceed bool) {
-	tagInfo := jsonTags.FieldTags(field)
-
+func (a *analyzer) checkField(pass *analysis.Pass, field *ast.Field, tagInfo extractjsontags.FieldTagInfo) {
 	var prefix string
 	if len(field.Names) > 0 && field.Names[0] != nil {
 		prefix = fmt.Sprintf("field %s", field.Names[0].Name)
@@ -112,29 +73,22 @@ func (a *analyzer) checkField(pass *analysis.Pass, field *ast.Field, jsonTags ex
 
 	if tagInfo.Missing {
 		pass.Reportf(field.Pos(), "%s is missing json tag", prefix)
-		return true
+		return
 	}
 
 	if tagInfo.Inline {
-		return true
-	}
-
-	if tagInfo.Ignored {
-		// Returning false here means we won't inspect the children of an ignored field.
-		return false
+		return
 	}
 
 	if tagInfo.Name == "" {
 		pass.Reportf(field.Pos(), "%s has empty json tag", prefix)
-		return true
+		return
 	}
 
 	matched := a.jsonTagRegex.Match([]byte(tagInfo.Name))
 	if !matched {
 		pass.Reportf(field.Pos(), "%s json tag does not match pattern %q: %s", prefix, a.jsonTagRegex.String(), tagInfo.Name)
 	}
-
-	return true
 }
 
 func defaultConfig(cfg *config.JSONTagsConfig) {

pkg/analysis/jsontags/testdata/src/a/a.go

@@ -46,3 +46,7 @@ type C struct{}
 type D struct{}
 
 type E struct{}
+
+type Interface interface {
+	InaccessibleFunction() string
+}

pkg/analysis/maxlength/analyzer.go

@@ -5,10 +5,10 @@ import (
 	"fmt"
 	"go/ast"
 
+	"github.com/JoelSpeed/kal/pkg/analysis/helpers/extractjsontags"
+	"github.com/JoelSpeed/kal/pkg/analysis/helpers/inspector"
 	"github.com/JoelSpeed/kal/pkg/analysis/helpers/markers"
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/analysis/passes/inspect"
-	"golang.org/x/tools/go/ast/inspector"
 )
 
 const (
@@ -27,7 +27,6 @@ const (
 
 var (
 	errCouldNotGetInspector = errors.New("could not get inspector")
-	errCouldNotGetMarkers   = errors.New("could not get markers")
 )
 
 // Analyzer is the analyzer for the maxlength package.
@@ -36,38 +35,17 @@ var Analyzer = &analysis.Analyzer{
 	Name:     name,
 	Doc:      "Checks that all strings formatted fields are marked with a maximum length, and that arrays are marked with max items.",
 	Run:      run,
-	Requires: []*analysis.Analyzer{inspect.Analyzer, markers.Analyzer},
+	Requires: []*analysis.Analyzer{inspector.Analyzer},
 }
 
 func run(pass *analysis.Pass) (interface{}, error) {
-	inspect, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+	inspect, ok := pass.ResultOf[inspector.Analyzer].(inspector.Inspector)
 	if !ok {
 		return nil, errCouldNotGetInspector
 	}
 
-	markersAccess, ok := pass.ResultOf[markers.Analyzer].(markers.Markers)
-	if !ok {
-		return nil, errCouldNotGetMarkers
-	}
-
-	// Filter to structs so that we can iterate over the fields in a struct.
-	nodeFilter := []ast.Node{
-		(*ast.StructType)(nil),
-	}
-
-	inspect.Preorder(nodeFilter, func(n ast.Node) {
-		sTyp, ok := n.(*ast.StructType)
-		if !ok {
-			return
-		}
-
-		if sTyp.Fields == nil {
-			return
-		}
-
-		for _, field := range sTyp.Fields.List {
-			checkField(pass, field, markersAccess)
-		}
+	inspect.InspectFields(func(field *ast.Field, stack []ast.Node, jsonTagInfo extractjsontags.FieldTagInfo, markersAccess markers.Markers) {
+		checkField(pass, field, markersAccess)
 	})
 
 	return nil, nil //nolint:nilnil

pkg/analysis/maxlength/testdata/src/a/a.go

@@ -72,6 +72,13 @@ type MaxLength struct {
 	StringAliasArrayWithMaxItemsAndMaxElementLengthOnAlias []StringAliasWithMaxLength
 
 	StringAliasArrayWithoutMaxItemsWithMaxElementLengthOnAlias []StringAliasWithMaxLength // want  "field StringAliasArrayWithoutMaxItemsWithMaxElementLengthOnAlias must have a maximum items, add kubebuilder:validation:MaxItems"
+
+	Struct struct {
+		// +kubebuilder:validation:MaxLength:=256
+		StringWithMaxLength string
+
+		StringWithoutMaxLength string // want "field StringWithoutMaxLength must have a maximum length, add kubebuilder:validation:MaxLength marker"
+	} `json:"struct"`
 }
 
 // StringAlias is a string without a MaxLength.