lint

Documentation

Overview

Package lint implements the linting machinery.

Index

• Constants
• func Name(name string, allowlist, blocklist []string) (should string)
• type AbstractRule
• type Arguments
• type Config
• type DirectiveConfig
• type DirectivesConfig
• type DisabledInterval
• type Failure
  • func (f *Failure) GetFilename() string
• type FailurePosition
  • func ToFailurePosition(start, end token.Pos, file *File) FailurePosition
• type File
  • func NewFile(name string, content []byte, pkg *Package) (*File, error)
  • func (f *File) CommentMap() ast.CommentMap
  • func (f *File) Content() []byte
  • func (f *File) IsTest() bool
  • func (f *File) IsUntypedConst(expr ast.Expr) (defType string, ok bool)
  • func (f *File) Render(x interface{}) string
  • func (f *File) ToPosition(pos token.Pos) token.Position
• type FileFilter
  • func ParseFileFilter(rawFilter string) (*FileFilter, error)
  • func (ff *FileFilter) MatchFileName(name string) bool
  • func (ff *FileFilter) String() string
• type FileFilters
• type Formatter
• type FormatterMetadata
• type Linter
  • func New(reader ReadFile, maxOpenFiles int) Linter
  • func (l *Linter) Lint(packages [][]string, ruleSet []Rule, config Config) (<-chan Failure, error)
• type Package
  • func (p *Package) Files() map[string]*File
  • func (p *Package) IsAtLeastGo122() bool
  • func (p *Package) IsMain() bool
  • func (p *Package) Sortable() map[string]bool
  • func (p *Package) TypeCheck() error
  • func (p *Package) TypeOf(expr ast.Expr) types.Type
  • func (p *Package) TypesInfo() *types.Info
  • func (p *Package) TypesPkg() *types.Package
• type ReadFile
• type Rule
• type RuleConfig
  • func (rc *RuleConfig) Initialize() error
  • func (rc *RuleConfig) MustExclude(name string) bool
• type RulesConfig
• type Severity

Constants

const (
	// SeverityWarning declares failures of type warning
	SeverityWarning = "warning"
	// SeverityError declares failures of type error.
	SeverityError = "error"
)

Functions

func Name

func Name(name string, allowlist, blocklist []string) (should string)

Name returns a different name if it should be different.

Types

type AbstractRule

type AbstractRule struct {
	Failures []Failure
}

AbstractRule defines an abstract rule.

type Arguments

type Arguments = []interface{}

Arguments is type used for the arguments of a rule.

type Config

type Config struct {
	IgnoreGeneratedHeader bool `toml:"ignoreGeneratedHeader"`
	Confidence            float64
	Severity              Severity
	EnableAllRules        bool             `toml:"enableAllRules"`
	Rules                 RulesConfig      `toml:"rule"`
	ErrorCode             int              `toml:"errorCode"`
	WarningCode           int              `toml:"warningCode"`
	Directives            DirectivesConfig `toml:"directive"`
	Exclude               []string         `toml:"exclude"`
	// If set, overrides the go language version specified in go.mod of
	// packages being linted, and assumes this specific language version.
	GoVersion *goversion.Version
}

Config defines the config of the linter.

type DirectiveConfig

type DirectiveConfig struct {
	Severity Severity
}

DirectiveConfig is type used for the linter directive configuration.

type DirectivesConfig

type DirectivesConfig = map[string]DirectiveConfig

DirectivesConfig defines the config for all directives.

type DisabledInterval

type DisabledInterval struct {
	From     token.Position
	To       token.Position
	RuleName string
}

DisabledInterval contains a single disabled interval and the associated rule name.

type Failure

type Failure struct {
	Failure    string
	RuleName   string
	Category   string
	Position   FailurePosition
	Node       ast.Node `json:"-"`
	Confidence float64
	// For future use
	ReplacementLine string
}

Failure defines a struct for a linting failure.

func (*Failure) GetFilename

func (f *Failure) GetFilename() string

GetFilename returns the filename.

type FailurePosition

type FailurePosition struct {
	Start token.Position
	End   token.Position
}

FailurePosition returns the failure position

func ToFailurePosition

func ToFailurePosition(start, end token.Pos, file *File) FailurePosition

ToFailurePosition returns the failure position.

type File

type File struct {
	Name string
	Pkg  *Package

	AST *ast.File
	// contains filtered or unexported fields
}

File abstraction used for representing files.

func NewFile

func NewFile(name string, content []byte, pkg *Package) (*File, error)

NewFile creates a new file

func (*File) CommentMap

func (f *File) CommentMap() ast.CommentMap

CommentMap builds a comment map for the file.

func (*File) Content

func (f *File) Content() []byte

Content returns the file's content.

func (*File) IsTest

func (f *File) IsTest() bool

IsTest returns if the file contains tests.

func (*File) IsUntypedConst

func (f *File) IsUntypedConst(expr ast.Expr) (defType string, ok bool)

IsUntypedConst reports whether expr is an untyped constant, and indicates what its default type is. scope may be nil.

func (*File) Render

func (f *File) Render(x interface{}) string

Render renders a node.

func (*File) ToPosition

func (f *File) ToPosition(pos token.Pos) token.Position

ToPosition returns line and column for given position.

type FileFilter

type FileFilter struct {
	// contains filtered or unexported fields
}

FileFilter - file filter to exclude some files for rule supports whole 1. file/dir names : pkg/mypkg/my.go, 2. globs: **/*.pb.go, 3. regexes (~ prefix) ~-tmp\.\d+\.go 4. special test marker `TEST` - treats as `~_test\.go`

func ParseFileFilter

func ParseFileFilter(rawFilter string) (*FileFilter, error)

ParseFileFilter - creates FileFilter for given raw filter if empty string, it matches nothing if `*`, or `~`, it matches everything while regexp could be invalid, it could return it's compilation error

func (*FileFilter) MatchFileName

func (ff *FileFilter) MatchFileName(name string) bool

MatchFileName - checks if file name matches filter

func (*FileFilter) String

func (ff *FileFilter) String() string

type FileFilters

type FileFilters = []*FileFilter

FileFilters is type used for modeling file filters to apply to rules.

type Formatter

type Formatter interface {
	Format(<-chan Failure, Config) (string, error)
	Name() string
}

Formatter defines an interface for failure formatters

type FormatterMetadata

type FormatterMetadata struct {
	Name        string
	Description string
	Sample      string
}

FormatterMetadata configuration of a formatter

type Linter

type Linter struct {
	// contains filtered or unexported fields
}

Linter is used for linting set of files.

func New

func New(reader ReadFile, maxOpenFiles int) Linter

New creates a new Linter

func (*Linter) Lint

func (l *Linter) Lint(packages [][]string, ruleSet []Rule, config Config) (<-chan Failure, error)

Lint lints a set of files with the specified rule.

type Package

type Package struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

Package represents a package in the project.

func (*Package) Files

func (p *Package) Files() map[string]*File

Files return package's files.

func (*Package) IsAtLeastGo122

func (p *Package) IsAtLeastGo122() bool

IsAtLeastGo122 returns true if the Go version for this package is 1.22 or higher, false otherwise

func (*Package) IsMain

func (p *Package) IsMain() bool

IsMain returns if that's the main package.

func (*Package) Sortable

func (p *Package) Sortable() map[string]bool

Sortable yields a map of sortable types in this package

func (*Package) TypeCheck

func (p *Package) TypeCheck() error

TypeCheck performs type checking for given package.

func (*Package) TypeOf

func (p *Package) TypeOf(expr ast.Expr) types.Type

TypeOf returns the type of an expression.

func (*Package) TypesInfo

func (p *Package) TypesInfo() *types.Info

TypesInfo yields type information of this package identifiers

func (*Package) TypesPkg

func (p *Package) TypesPkg() *types.Package

TypesPkg yields information on this package

type ReadFile

type ReadFile func(path string) (result []byte, err error)

ReadFile defines an abstraction for reading files.

type Rule

type Rule interface {
	Name() string
	Apply(*File, Arguments) []Failure
}

Rule defines an abstract rule interface

type RuleConfig

type RuleConfig struct {
	Arguments Arguments
	Severity  Severity
	Disabled  bool
	// Exclude - rule-level file excludes, TOML related (strings)
	Exclude []string
	// contains filtered or unexported fields
}

RuleConfig is type used for the rule configuration.

func (*RuleConfig) Initialize

func (rc *RuleConfig) Initialize() error

Initialize - should be called after reading from TOML file

func (*RuleConfig) MustExclude

func (rc *RuleConfig) MustExclude(name string) bool

MustExclude - checks if given filename `name` must be excluded

type RulesConfig

type RulesConfig = map[string]RuleConfig

RulesConfig defines the config for all rules.

type Severity

type Severity string

Severity is the type for the failure types.