swamp_script_analyzer/
err.rs

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
/*
 * Copyright (c) Peter Bjorklund. All rights reserved. https://github.com/swamp/script
 * Licensed under the MIT License. See LICENSE in the project root for license information.
 */

use seq_map::SeqMapError;
use std::num::{ParseFloatError, ParseIntError};
use swamp_script_ast::{LocalTypeIdentifier, Pattern};
use swamp_script_semantic::{
    ResolvedAnonymousStructType, ResolvedEnumVariantTypeRef, ResolvedNode, ResolvedStructTypeRef,
    ResolvedType, SemanticError, Span,
};

#[derive(Debug)]
pub enum ResolveError {
    TooManyDestructureVariables,
    CanNotDestructure(Span),
    EmptyArrayCanOnlyBeMapOrArray,
    NamespaceError(NamespaceError),
    CanNotFindModule(Vec<String>),
    UnknownStructTypeReference(ResolvedNode),
    UnknownLocalStructTypeReference(LocalTypeIdentifier),
    DuplicateFieldName(ResolvedNode),
    Unknown(String),
    UnknownImplTargetTypeReference(LocalTypeIdentifier),
    WrongFieldCountInStructInstantiation(ResolvedStructTypeRef, usize),
    MissingFieldInStructInstantiation(Span, Vec<String>, ResolvedAnonymousStructType),
    ExpectedFunctionExpression,
    CouldNotFindMember(ResolvedNode, ResolvedNode),
    UnknownVariable(ResolvedNode),
    NotAnArray(Span),
    ArrayIndexMustBeInt(ResolvedType),
    OverwriteVariableWithAnotherType(ResolvedNode),
    ExpectedMutableLocation(Span),
    WrongNumberOfArguments(usize, usize),
    IncompatibleArguments(Span, ResolvedType, ResolvedType),
    CanOnlyOverwriteVariableWithMut(ResolvedNode),
    OverwriteVariableNotAllowedHere(ResolvedNode),
    NotNamedStruct(ResolvedType),
    UnknownEnumVariantType(ResolvedNode),
    WasNotStructType(ResolvedNode),
    UnknownStructField(ResolvedNode),
    MustBeEnumType(Pattern),
    UnknownEnumVariantTypeInPattern(ResolvedNode),
    ExpectedEnumInPattern(ResolvedNode),
    WrongEnumVariantContainer(ResolvedEnumVariantTypeRef),
    VariableIsNotMutable(ResolvedNode),
    ArgumentIsNotMutable(Span),
    WrongNumberOfTupleDeconstructVariables,
    UnknownTypeReference(ResolvedNode),
    SemanticError(SemanticError),
    SeqMapError(SeqMapError),
    ExpectedMemberCall(ResolvedNode),
    CouldNotFindStaticMember(ResolvedNode, ResolvedNode),
    TypeAliasNotAStruct(ResolvedNode),
    ModuleNotUnique,
    ExpressionIsOfWrongFieldType(Span, ResolvedType, ResolvedType),
    ExpectedOptional,
    ExpectedVariable(ResolvedNode),
    EmptyMapLiteral,
    MapKeyTypeMismatch {
        expected: ResolvedType,
        found: ResolvedType,
    },
    MapValueTypeMismatch {
        expected: ResolvedType,
        found: ResolvedType,
    },
    TypeIsNotAnIndexCollection(ResolvedType),
    NotSameKeyTypeForMapIndex(ResolvedType, ResolvedType),
    NonUniqueKeyValueInMap(SeqMapError),
    UnknownIndexAwareCollection,
    InvalidOperatorForArray(ResolvedNode),
    IncompatibleTypes(Span, ResolvedType),
    ExpectedArray(ResolvedType),
    UnknownMemberFunction(ResolvedNode),
    WrongNumberOfTypeArguments(usize, i32),
    OnlyVariablesAllowedInEnumPattern,
    ExpressionsNotAllowedInLetPattern,
    UnknownField(ResolvedNode),
    EnumVariantHasNoFields(ResolvedNode),
    TooManyTupleFields {
        max: usize,
        got: usize,
    },
    NotInFunction,
    ExpectedBooleanExpression(Span),
    NotAnIterator(Span),
    UnsupportedIteratorPairs,
    NeedStructForFieldLookup,
    IntConversionError(ParseIntError),
    FloatConversionError(ParseFloatError),
    BoolConversionError,
    DuplicateFieldInStructInstantiation(String),
    InternalError(&'static str),
    WasNotFieldMutRef,
    UnknownFunction(ResolvedNode),
    NoDefaultImplemented(ResolvedType),
    NoDefaultImplementedForStruct(ResolvedStructTypeRef),
    UnknownConstant(ResolvedNode),
    ExpectedFunctionTypeForFunctionCall(Span),
    TypeDoNotSupportIndexAccess(Span),
    NoneCoalesceNeedsOptionalType(Span),
    TypeDoNotSupportRangeAccess(Span),
}

impl From<SemanticError> for ResolveError {
    fn from(value: SemanticError) -> Self {
        Self::SemanticError(value)
    }
}

impl From<SeqMapError> for ResolveError {
    fn from(value: SeqMapError) -> Self {
        Self::SeqMapError(value)
    }
}

#[derive(Debug)]
pub enum NamespaceError {}

impl From<NamespaceError> for ResolveError {
    fn from(error: NamespaceError) -> Self {
        Self::NamespaceError(error)
    }
}