lint

Documentation

Index

• Constants
• func Name(name string, whitelist, blacklist []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 token.Pos, end token.Pos, file *File) FailurePosition
• type File
  • func NewFile(name string, pkg *Package, ast *ast.File) (*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 Formatter
• type FormatterMetadata
• type Linter
  • func New(reader ReadFile) Linter
  • func (l *Linter) Lint(pkgs []*packages.Package, ruleSet []Rule, config Config) (<-chan Failure, error)
• type Package
  • func (p *Package) Fset() *token.FileSet
  • func (p *Package) IsMain() bool
  • func (p *Package) TypeCheck() error
  • func (p *Package) TypeOf(expr ast.Expr) types.Type
• type ReadFile
• type Rule
• type RuleConfig
• 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, whitelist, blacklist []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
	Rules                 RulesConfig      `toml:"rule"`
	ErrorCode             int              `toml:"errorCode"`
	WarningCode           int              `toml:"warningCode"`
	Directives            DirectivesConfig `toml:"directive"`
}

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 token.Pos, 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, pkg *Package, ast *ast.File) (*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 renters a node.

func (*File) ToPosition

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

ToPosition returns line and column for given position.

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) Linter

New creates a new Linter

func (*Linter) Lint

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

Lint lints a set of files with the specified rule.

type Package

type Package struct {
	Name      string
	TypesPkg  *types.Package
	TypesInfo *types.Info

	// sortable is the set of types in the package that implement sort.Interface.
	Sortable map[string]bool
	// contains filtered or unexported fields
}

Package represents a package in the project.

func (*Package) Fset

func (p *Package) Fset() *token.FileSet

func (*Package) IsMain

func (p *Package) IsMain() bool

IsMain returns if that's the main 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

check function encapsulates the call to go/types.Config.Check method and recovers if the called method panics (see issue #59)

func check(config *types.Config, n string, fset *token.FileSet, astFiles []*ast.File, info *types.Info) (p *types.Package, err error) {
	defer func() {
		if r := recover(); r != nil {
			err, _ = r.(error)
			p = nil
			return
		}
	}()

	return config.Check(n, fset, astFiles, info)
}

TypeOf returns the type of an expression.

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
	ApplyToFile(*File, Arguments) []Failure
	ApplyToPackage(*Package, Arguments, chan Failure)
}

Rule defines an abstract rule interaface

type RuleConfig

type RuleConfig struct {
	Arguments Arguments
	Severity  Severity
}

RuleConfig is type used for the rule configuration.

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.