typecheck

type BadArity ¶

type BadArity struct{ Expected, Actual int }

func (e BadArity) Message() string

func (BadArity) Severity() Severity

type DuplicateVariable ¶

type DuplicateVariable struct{ Name string }

func (e DuplicateVariable) Message() string

func (DuplicateVariable) Severity() Severity

type Error ¶

type Error struct {
	Range parser.Range
	Kind  ErrorKind
}

type ErrorKind ¶

type ErrorKind interface {
	Message() string
	Severity() Severity
	// contains filtered or unexported methods
}

ErrorKind is both a typecheck error and a renderable diagnostic (Message + Severity), so callers can push it as a diagnostic without a translation layer.

type InvalidType ¶

type InvalidType struct{ Name string }

func (e InvalidType) Message() string

func (InvalidType) Severity() Severity

type Result ¶

type Result struct {
	ExprTypes map[parser.ValueExpr]Type
	VarTypes  map[string]Type
	Errors    []Error
}

func Check(program parser.Program) Result

type Severity ¶

type Severity = byte

Severity mirrors the LSP DiagnosticSeverity spec (and analysis.Severity, an alias of byte too) so an ErrorKind directly satisfies analysis.DiagnosticKind.

type Type ¶

type Type = string

const (
	TypeNumber   Type = "number"
	TypeString   Type = "string"
	TypeAsset    Type = "asset"
	TypeMonetary Type = "monetary"
	TypeAccount  Type = "account"
	TypePortion  Type = "portion"

	// TypeAny is the type of an expression whose type couldn't be determined
	// (e.g. an unbound variable or an unknown function). It's compatible with
	// everything, so it suppresses cascading errors.
	TypeAny Type = "any"
)

type TypeMismatch ¶

type TypeMismatch struct{ Expected, Got string }

func (e TypeMismatch) Message() string

func (TypeMismatch) Severity() Severity

type UnboundVariable ¶

type UnboundVariable struct{ Name, Type string }

func (e UnboundVariable) Message() string

func (UnboundVariable) Severity() Severity

type UnknownFunction ¶

type UnknownFunction struct{ Name, WrongContext string }

UnknownFunction is either a truly-unknown name (WrongContext == "") or a known builtin used in the wrong context (WrongContext is the context it belongs to, e.g. "statement"). typecheck only ever emits the former.

func (e UnknownFunction) Message() string

func (UnknownFunction) Severity() Severity