lint

type AbstractRule struct {
	Failures []Failure
}

type Arguments = []interface{}

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"`
}

type DirectiveConfig struct {
	Severity Severity
}

type DirectivesConfig = map[string]DirectiveConfig

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

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

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

type File struct {
	Name string
	Pkg  *Package

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

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

type FormatterMetadata struct {
	Name        string
	Description string
	Sample      string
}

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

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
}

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

type Rule interface {
	Name() string
	ApplyToFile(*File, Arguments) []Failure
	ApplyToPackage(*Package, Arguments, chan Failure)
}

type RuleConfig struct {
	Arguments Arguments
	Severity  Severity
}

type RulesConfig = map[string]RuleConfig

type Severity string