analysis

type Analyzer struct {
	Description string

	Run func(*Pass) interface{}

	// Requires is a set of analyzers that must run before this one.
	// This analyzer may inspect the outputs produced by each analyzer in Requires.
	// The graph over analyzers implied by Requires edges must be acyclic
	Requires []*Analyzer
}

type Config struct {
	// ResolveAddressContractNames is called to resolve the contract names of an address location
	ResolveAddressContractNames func(address common.Address) ([]string, error)
	// ResolveCode is called to resolve an import to its source code
	ResolveCode func(
		location common.Location,
		importingLocation common.Location,
		importRange ast.Range,
	) ([]byte, error)
	// Mode controls the level of information returned for each program
	Mode LoadMode
	// HandleParserError is called when a parser error occurs instead of returning it
	HandleParserError func(err ParsingCheckingError, program *ast.Program) error
	// HandleCheckerError is called when a checker error occurs instead of returning it
	HandleCheckerError func(err ParsingCheckingError, checker *sema.Checker) error
	// CryptoContractElaboration is the elaboration of the Crypto contract
	CryptoContractElaboration *sema.Elaboration
}

type Diagnostic struct {
	Location         common.Location
	Category         string
	Message          string
	SecondaryMessage string
	Code             string // Diagnostic code (e.g. "unused-variable")
	URL              string // URL to documentation
	SuggestedFixes   []SuggestedFix
	ast.Range
}

type LoadMode int

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

type Pass struct {
	Program *Program

	// Report reports a Diagnostic, a finding about a specific location
	// in the analyzed source code such as a potential mistake.
	// It may be called by the Analyzer.Run function.
	Report func(Diagnostic)

	// ResultOf provides the inputs to this analysis pass,
	// which are the corresponding results of its prerequisite analyzers.
	// The map keys are the elements of Analyzer.Requires.
	ResultOf map[*Analyzer]interface{}
}

type Program struct {
	Location  common.Location
	Program   *ast.Program
	Checker   *sema.Checker
	Code      []byte
	LoadError error
}

type Programs struct {
	Programs                  map[common.Location]*Program
	CryptoContractElaboration *sema.Elaboration
	CryptoContractLocation    func() common.Location
}

type SuggestedFix = errors.SuggestedFix[ast.TextEdit]

type TextEdit = ast.TextEdit