lint

type AbstractRule struct {
	Failures []Failure
}

type Arguments = []interface{}

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

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 {
	sync.RWMutex
	// contains filtered or unexported fields
}

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

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

type RuleConfig struct {
	Arguments Arguments
	Severity  Severity
	Disabled  bool
}

type RulesConfig = map[string]RuleConfig

type Severity string