1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use analysis::TypeId;
use span::Span;
use ast::*;

#[derive(Clone, Debug)]
pub enum Err {
    ControlFlowErr(ControlFlowErr),
    TypeErr(TypeErr),
    ParseErr(String),
    MultipleMainFns,
    UnknownType(TypeAnnotation),
    UnknownBinding(Ident),
    UnknownFn(ModulePath),
    UnresolvedUses(Vec<AstNode<UseDecl>>),
    UnresolvedStructs(Vec<AstNode<Struct>>),
    UnresolvedFns(Vec<AstNode<Function>>),
    UncheckedFunctionBinding(Ident),
    MissingModName,
}

#[derive(Clone, Debug)]
pub enum ControlFlowErr {
    MissingReturn,
    BadBreak(Span),
    BadContinue(Span),
}

impl From<ControlFlowErr> for Err {
    fn from(err: ControlFlowErr) -> Err {
        Err::ControlFlowErr(err)
    }
}

#[derive(Clone, Debug)]
pub enum TypeErr {
    CyclicType(TypeId),
    LhsRhsInEq(TypeId, TypeId, Span),
    InEqFnReturn {
        expr: TypeId,
        fn_return: TypeId,
        return_span: Span,
    },

    UnexpectedType {
        found: TypeId,
        expected: TypeId,
        span: Span,
    },

    Arity {
        fn_type: TypeId,
        found_args: usize,
        expected_param: usize,
        span: Span,
    },

    BinOp {
        op: BinOp,
        expected: Vec<TypeId>,
        lhs: TypeId,
        rhs: TypeId,
        span: Span,
    },

    UniOp {
        op: UniOp,
        expected: Vec<TypeId>,
        expr: TypeId,
        span: Span,
    },

    ArgMismatch {
        fn_type_id: TypeId,
        index: usize,
        arg: TypeId,
        param: TypeId,
        span: Span,
    },

    FieldAccessOnNonStruct {
        path: Path,
        index: usize,
        invalid_type: TypeId,
        root_type: TypeId,
        span: Span,
    },

    NotAStruct {
        type_name: ModulePath,
        found: TypeId,
        span: Span,
    },

    StructNotFullyInitialized {
        type_name: ModulePath,
        struct_type: TypeId,
        missing_fields: Vec<Ident>,
        span: Span,
    },

    UnknownField {
        name: Ident,
        struct_type: TypeId,
        span: Span,
    },

    HeterogenousArray {
        expected: TypeId,
        found: TypeId,
        index: usize,
        span: Span,
    },

    NotAnArray {
        found: TypeId,
        span: Span,
    },

    InvalidIndex {
        found: TypeId,
        span: Span,
    },
}

impl From<TypeErr> for Err {
    fn from(err: TypeErr) -> Err {
        Err::TypeErr(err)
    }
}