use nash_ast::ModuleName;
use nash_ast::{Kind, QualifiedName};
use nash_region::{Located, Region};
use nash_source::Type as SourceType;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BadArityContext {
TypeArity,
PatternArity,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DuplicatePatternContext<'a> {
LambdaArgs,
FuncArgs(&'a str),
CaseBranch,
LetBinding,
Destruct,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum VarKind {
BadOp,
BadVar,
BadPattern,
BadType,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct PossibleNames<'a> {
pub locals: &'a [&'a str],
pub qualified: &'a [(&'a str, &'a [&'a str])],
}
#[derive(Clone, Debug)]
pub enum Error<'a> {
DuplicateTest {
name: &'a str,
first: Region,
second: Region,
},
ValidatorMissingMain {
region: Region,
module: &'a str,
},
ValidatorMainNotExposed {
region: Region,
module: &'a str,
},
RecordLiteralNoAlias {
region: Region,
fields: &'a [&'a str],
},
RecordLiteralAmbiguous {
region: Region,
candidates: &'a [QualifiedName<'a>],
},
RecordTypeOutsideAlias {
region: Region,
},
OutOfFuel {
region: Region,
},
NegateWithoutNum {
region: Region,
},
DoWithoutMonad {
region: Region,
},
RefutableBindPattern {
region: Region,
},
StructuralEqOverride {
head: &'a Located<nash_ast::Type<'a>>,
},
ReflexiveLiftOverlap {
heads: &'a [&'a Located<nash_ast::Type<'a>>],
},
MissingSuperclass {
region: Region,
trait_: QualifiedName<'a>,
heads: &'a [Located<nash_ast::Head<'a>>],
superclass: &'a nash_ast::Pred<'a>,
index: u16,
reason: crate::entailment::Failure,
},
BadInstanceHead {
region: Region,
reason: BadHead,
},
ImplContextVarNotInHead {
region: Region,
name: &'a str,
},
MissingMethod {
region: Region,
trait_: &'a str,
name: &'a str,
},
UnknownMethod {
region: Region,
trait_: &'a str,
name: &'a str,
},
OrphanImpl {
region: Region,
trait_: QualifiedName<'a>,
heads: &'a [nash_ast::HeadCon<'a>],
},
OverlappingImpls {
key: &'a nash_ast::ImplKey<'a>,
first: Region,
second: Region,
first_home: ModuleName<'a>,
second_home: ModuleName<'a>,
},
ImportOpenTrait {
region: Region,
name: &'a str,
},
DuplicateTrait {
name: &'a str,
first: Region,
second: Region,
},
DuplicateMethod {
name: &'a str,
first: Region,
second: Region,
},
DuplicateTraitParameter {
name: &'a str,
first: Region,
second: Region,
},
SuperclassBadArg {
region: Region,
trait_: &'a str,
},
MethodMissingParameter {
region: Region,
method: &'a str,
parameter: &'a str,
},
RecursiveSuperclass {
names: &'a [&'a Located<&'a str>],
},
ExportOpenTrait {
region: Region,
name: &'a str,
},
NotFoundTrait {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
},
AmbiguousTrait {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
TraitArity {
region: Region,
name: &'a str,
expected: usize,
actual: usize,
},
ContextVarNotInType {
region: Region,
name: &'a str,
},
KindMismatch {
region: Region,
context: &'a KindContext<'a>,
expected: &'a Kind<'a>,
actual: &'a Kind<'a>,
},
KindInfinite {
region: Region,
context: &'a KindContext<'a>,
},
RepresentationMismatch {
region: Region,
context: &'a KindContext<'a>,
required: nash_ast::primitives::ReprTrait,
actual: nash_ast::primitives::Repr,
},
ContradictoryRepresentation {
region: Region,
subject: &'a Located<nash_ast::Type<'a>>,
},
ImplOfBuiltinTrait {
region: Region,
trait_: QualifiedName<'a>,
},
IrregularRecursion {
region: Region,
constructor: QualifiedName<'a>,
parameter: &'a str,
},
Unsupported {
feature: &'static str,
region: Region,
},
MissingModuleHeader,
NotFoundType {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
suggestions: PossibleNames<'a>,
},
ImportNotFound {
region: Region,
module: &'a str,
},
AmbiguousType {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
BadArity {
region: Region,
context: BadArityContext,
name: &'a str,
expected: usize,
actual: usize,
},
ExportNotFound {
region: Region,
kind: VarKind,
name: &'a str,
suggestions: &'a [&'a str],
},
ExportOpenAlias {
region: Region,
name: &'a str,
},
DuplicateDecl {
name: &'a str,
first: Region,
second: Region,
},
DuplicateType {
name: &'a str,
first: Region,
second: Region,
},
DuplicateCtor {
name: &'a str,
first: Region,
second: Region,
},
DuplicateBinop {
name: &'a str,
first: Region,
second: Region,
},
BinopFunctionNotFound {
region: Region,
op: &'a str,
function: &'a str,
},
DuplicateUnionArg {
type_name: &'a str,
arg_name: &'a str,
first: Region,
second: Region,
},
DuplicateAliasArg {
type_name: &'a str,
arg_name: &'a str,
first: Region,
second: Region,
},
RecursiveAlias {
region: Region,
name: &'a str,
args: &'a [&'a str],
typ: &'a Located<SourceType<'a>>,
others: &'a [&'a str],
},
TypeVarsUnboundInUnion {
region: Region,
name: &'a str,
args: &'a [&'a str],
unbound: (&'a str, Region),
more_unbound: &'a [(&'a str, Region)],
},
TypeVarsMessedUpInAlias {
region: Region,
name: &'a str,
args: &'a [&'a str],
unused: &'a [(&'a str, Region)],
unbound: &'a [(&'a str, Region)],
},
LabeledCtorMissingField {
region: Region,
ctor: &'a str,
field: &'a str,
},
LabeledCtorExtraField {
region: Region,
ctor: &'a str,
field: &'a str,
},
LabeledCtorUnknownField {
region: Region,
ctor: &'a str,
field: &'a str,
},
DuplicateField {
name: &'a str,
first: Region,
second: Region,
},
ExportDuplicate {
name: &'a str,
first: Region,
second: Region,
},
NotFoundCtor {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
suggestions: PossibleNames<'a>,
},
AmbiguousCtor {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
PatternHasRecordCtor {
region: Region,
name: &'a str,
},
DuplicatePattern {
context: DuplicatePatternContext<'a>,
name: &'a str,
first: Region,
second: Region,
},
NotFoundVar {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
suggestions: PossibleNames<'a>,
},
AmbiguousVar {
region: Region,
prefix: Option<&'a str>,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
NotFoundBinop {
region: Region,
name: &'a str,
available: &'a [&'a str],
},
AmbiguousBinop {
region: Region,
name: &'a str,
first_module: ModuleName<'a>,
other_modules: &'a [ModuleName<'a>],
},
BinopConflict {
region: Region,
op1: &'a str,
op2: &'a str,
},
Shadowing {
name: &'a str,
original: Region,
new: Region,
},
RecursiveLet {
name: &'a Located<&'a str>,
others: &'a [&'a str],
},
RecursiveDecl {
name: &'a Located<&'a str>,
others: &'a [&'a str],
},
AnnotationTooShort {
region: Region,
name: &'a str,
index: usize,
leftovers: usize,
},
ImportExposingNotFound {
region: Region,
module: ModuleName<'a>,
name: &'a str,
available: &'a [&'a str],
},
ImportCtorByName {
region: Region,
name: &'a str,
type_name: &'a str,
},
ImportOpenAlias {
region: Region,
name: &'a str,
},
}
#[derive(Clone, Copy, Debug)]
pub enum KindContext<'a> {
TypeAnnotation,
BigField {
union: &'a str,
ctor: &'a str,
index: u16,
},
LittleField {
union: &'a str,
ctor: &'a str,
index: u16,
},
RecordField {
alias: &'a str,
field: &'a str,
big: bool,
},
AliasCasing {
alias: &'a str,
big: bool,
},
Annotation {
name: &'a str,
},
ImplHead {
trait_: QualifiedName<'a>,
index: u16,
},
}
#[derive(Clone, Copy, Debug)]
pub enum BadHead {
BareVariable,
Function,
Record,
VariableApplication,
}