sway_error/
convert_parse_tree_error.rs

1use sway_types::{Ident, IdentUnique, Span, Spanned};
2use thiserror::Error;
3
4use crate::formatting::{
5    a_or_an, num_to_str, num_to_str_or_none, plural_s, sequence_to_str, Enclosing,
6};
7
8#[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
9pub enum ConvertParseTreeError {
10    #[error("Imports without items are not supported")]
11    ImportsWithoutItemsNotSupported { span: Span },
12    #[error("functions used in applications may not be arbitrary expressions")]
13    FunctionArbitraryExpression { span: Span },
14    #[error("generics are not supported here")]
15    GenericsNotSupportedHere { span: Span },
16    #[error("multiple generics are not supported")]
17    MultipleGenericsNotSupported { span: Span },
18    #[error("tuple index out of range")]
19    TupleIndexOutOfRange { span: Span },
20    #[error("shift-left expressions are not implemented")]
21    ShlNotImplemented { span: Span },
22    #[error("shift-right expressions are not implemented")]
23    ShrNotImplemented { span: Span },
24    #[error("bitwise xor expressions are not implemented")]
25    BitXorNotImplemented { span: Span },
26    #[error("integer literals in this position cannot have a type suffix")]
27    IntTySuffixNotSupported { span: Span },
28    #[error("int literal out of range")]
29    IntLiteralOutOfRange { span: Span },
30    #[error("expected an integer literal")]
31    IntLiteralExpected { span: Span },
32    #[error("qualified path roots are not implemented")]
33    QualifiedPathRootsNotImplemented { span: Span },
34    #[error("char literals are not implemented")]
35    CharLiteralsNotImplemented { span: Span },
36    #[error("hex literals must have 1..16 or 64 digits")]
37    HexLiteralLength { span: Span },
38    #[error("binary literals must have either 1..64 or 256 digits")]
39    BinaryLiteralLength { span: Span },
40    #[error("u8 literal out of range")]
41    U8LiteralOutOfRange { span: Span },
42    #[error("u16 literal out of range")]
43    U16LiteralOutOfRange { span: Span },
44    #[error("u32 literal out of range")]
45    U32LiteralOutOfRange { span: Span },
46    #[error("u64 literal out of range")]
47    U64LiteralOutOfRange { span: Span },
48    #[error("signed integers are not supported")]
49    SignedIntegersNotSupported { span: Span },
50    #[error("ref variables are not supported")]
51    RefVariablesNotSupported { span: Span },
52    #[error("literal patterns not supported in this position")]
53    LiteralPatternsNotSupportedHere { span: Span },
54    #[error("constant patterns not supported in this position")]
55    ConstantPatternsNotSupportedHere { span: Span },
56    #[error("constructor patterns not supported in this position")]
57    ConstructorPatternsNotSupportedHere { span: Span },
58    #[error("struct patterns not supported in this position")]
59    StructPatternsNotSupportedHere { span: Span },
60    #[error("wildcard patterns not supported in this position")]
61    WildcardPatternsNotSupportedHere { span: Span },
62    #[error("or patterns not supported in this position")]
63    OrPatternsNotSupportedHere { span: Span },
64    #[error("tuple patterns not supported in this position")]
65    TuplePatternsNotSupportedHere { span: Span },
66    #[error("ref patterns not supported in this position")]
67    RefPatternsNotSupportedHere { span: Span },
68    #[error("constructor patterns require a single argument")]
69    ConstructorPatternOneArg { span: Span },
70    #[error("constructor patterns cannot contain sub-patterns")]
71    ConstructorPatternSubPatterns { span: Span },
72    #[error("paths are not supported in this position")]
73    PathsNotSupportedHere { span: Span },
74    #[error("Fully specified types are not supported in this position. Try importing the type and referring to it here.")]
75    FullySpecifiedTypesNotSupported { span: Span },
76    #[error("ContractCaller requires exactly one generic argument")]
77    ContractCallerOneGenericArg { span: Span },
78    #[error("ContractCaller requires a named type for its generic argument")]
79    ContractCallerNamedTypeGenericArg { span: Span },
80    #[error("cannot find type \"{ty_name}\" in this scope")]
81    ConstrainedNonExistentType { ty_name: Ident, span: Span },
82    #[error("__get_storage_key does not take arguments")]
83    GetStorageKeyTooManyArgs { span: Span },
84    #[error("recursive types are not supported")]
85    RecursiveType { span: Span },
86    #[error("enum variant \"{name}\" already declared")]
87    DuplicateEnumVariant { name: Ident, span: Span },
88    #[error("storage field \"{name}\" already declared")]
89    DuplicateStorageField { name: Ident, span: Span },
90    #[error("configurable \"{name}\" already declared")]
91    DuplicateConfigurable { name: Ident, span: Span },
92    #[error("Multiple configurable blocks detected in this module")]
93    MultipleConfigurableBlocksInModule { span: Span },
94    #[error("struct field \"{name}\" already declared")]
95    DuplicateStructField { name: Ident, span: Span },
96    #[error("identifier \"{name}\" bound more than once in this parameter list")]
97    DuplicateParameterIdentifier { name: Ident, span: Span },
98    #[error("self parameter is not allowed for {fn_kind}")]
99    SelfParameterNotAllowedForFn { fn_kind: String, span: Span },
100    #[error("Expected module at the beginning before any other items.")]
101    ExpectedModuleAtBeginning { span: Span },
102    #[error("Constant requires expression.")]
103    ConstantRequiresExpression { span: Span },
104    #[error("Constant requires type ascription.")]
105    ConstantRequiresTypeAscription { span: Span },
106    #[error("Unknown type name \"self\". A self type with a similar name exists (notice the capitalization): `Self`")]
107    UnknownTypeNameSelf { span: Span },
108    #[error("{}", match get_attribute_type(attribute) {
109        AttributeType::InnerDocComment => format!("Inner doc comment (`//!`) cannot document {}{target_friendly_name}.", a_or_an(&target_friendly_name)),
110        AttributeType::OuterDocComment => format!("Outer doc comment (`///`) cannot document {}{target_friendly_name}.", a_or_an(&target_friendly_name)),
111        AttributeType::Attribute => format!("\"{attribute}\" attribute cannot annotate {}{target_friendly_name}.", a_or_an(&target_friendly_name)),
112    })]
113    InvalidAttributeTarget {
114        span: Span,
115        attribute: Ident,
116        target_friendly_name: &'static str,
117        can_only_annotate_help: Vec<&'static str>,
118    },
119    #[error("\"{last_occurrence}\" attribute can be applied only once, but is applied {} times.", num_to_str(previous_occurrences.len() + 1))]
120    InvalidAttributeMultiplicity {
121        last_occurrence: IdentUnique,
122        previous_occurrences: Vec<IdentUnique>,
123    },
124    #[error("\"{attribute}\" attribute must {}, but has {}.", get_expected_attributes_args_multiplicity_msg(args_multiplicity), num_to_str_or_none(*num_of_args))]
125    InvalidAttributeArgsMultiplicity {
126        span: Span,
127        attribute: Ident,
128        args_multiplicity: (usize, usize),
129        num_of_args: usize,
130    },
131    #[error(
132        "\"{arg}\" is an invalid argument for attribute \"{attribute}\". Valid arguments are: {}.",
133        sequence_to_str(expected_args, Enclosing::DoubleQuote, usize::MAX)
134    )]
135    InvalidAttributeArg {
136        attribute: Ident,
137        arg: IdentUnique,
138        expected_args: Vec<&'static str>,
139    },
140    #[error("\"{arg}\" argument of the attribute \"{attribute}\" must {}have a value.",
141        match value_span {
142            Some(_) => "not ",
143            None => "",
144        }
145    )]
146    InvalidAttributeArgExpectsValue {
147        attribute: Ident,
148        arg: IdentUnique,
149        value_span: Option<Span>,
150    },
151    #[error("\"{arg}\" argument must have a value of type \"{expected_type}\".")]
152    InvalidAttributeArgValueType {
153        span: Span,
154        arg: Ident,
155        expected_type: &'static str,
156        received_type: &'static str,
157    },
158    #[error("{} is an invalid value for argument \"{arg}\". Valid values are: {}.", span.as_str(), sequence_to_str(expected_values, Enclosing::DoubleQuote, usize::MAX))]
159    InvalidAttributeArgValue {
160        span: Span,
161        arg: Ident,
162        expected_values: Vec<&'static str>,
163    },
164}
165
166pub(crate) enum AttributeType {
167    /// `//!`.
168    InnerDocComment,
169    /// `///`.
170    OuterDocComment,
171    /// `#[attribute]` or `#![attribute]`.
172    Attribute,
173}
174
175pub(crate) fn get_attribute_type(attribute: &Ident) -> AttributeType {
176    // The doc-comment attribute name has the span that
177    // points to the actual comment line.
178    // Other attributes have spans that point to the actual
179    // attribute name.
180    let span = attribute.span();
181    let attribute = span.as_str();
182    if attribute.starts_with("//!") {
183        AttributeType::InnerDocComment
184    } else if attribute.starts_with("///") {
185        AttributeType::OuterDocComment
186    } else {
187        AttributeType::Attribute
188    }
189}
190
191pub(crate) fn get_expected_attributes_args_multiplicity_msg(
192    args_multiplicity: &(usize, usize),
193) -> String {
194    match *args_multiplicity {
195        (0, 0) => "not have any arguments".to_string(),
196        (min, max) if min == max => format!("have exactly {} argument{}", num_to_str(min), plural_s(min)),
197        (min, max) if min == max - 1 => format!("have {} or {} argument{}", num_to_str_or_none(min), num_to_str(max), plural_s(max)),
198        (0, max) if max != usize::MAX => format!("have at most {} argument{}", num_to_str(max), plural_s(max)), 
199        (min, usize::MAX) if min != usize::MIN => format!("have at least {} argument{}", num_to_str(min), plural_s(min)), 
200        (min, max) if max != usize::MAX => format!("have between {} and {} arguments", num_to_str(min), num_to_str(max)),
201        (0, usize::MAX) => unreachable!("if any number of arguments are accepted the `InvalidAttributeArgsMultiplicity` error cannot occur"),
202        _ => unreachable!("`min` is `always` less than or equal to `max` and all combinations are already covered"),
203    }
204}
205
206impl Spanned for ConvertParseTreeError {
207    fn span(&self) -> Span {
208        match self {
209            ConvertParseTreeError::ImportsWithoutItemsNotSupported { span } => span.clone(),
210            ConvertParseTreeError::FunctionArbitraryExpression { span } => span.clone(),
211            ConvertParseTreeError::GenericsNotSupportedHere { span } => span.clone(),
212            ConvertParseTreeError::MultipleGenericsNotSupported { span } => span.clone(),
213            ConvertParseTreeError::TupleIndexOutOfRange { span } => span.clone(),
214            ConvertParseTreeError::ShlNotImplemented { span } => span.clone(),
215            ConvertParseTreeError::ShrNotImplemented { span } => span.clone(),
216            ConvertParseTreeError::BitXorNotImplemented { span } => span.clone(),
217            ConvertParseTreeError::IntTySuffixNotSupported { span } => span.clone(),
218            ConvertParseTreeError::IntLiteralOutOfRange { span } => span.clone(),
219            ConvertParseTreeError::IntLiteralExpected { span } => span.clone(),
220            ConvertParseTreeError::QualifiedPathRootsNotImplemented { span } => span.clone(),
221            ConvertParseTreeError::CharLiteralsNotImplemented { span } => span.clone(),
222            ConvertParseTreeError::HexLiteralLength { span } => span.clone(),
223            ConvertParseTreeError::BinaryLiteralLength { span } => span.clone(),
224            ConvertParseTreeError::U8LiteralOutOfRange { span } => span.clone(),
225            ConvertParseTreeError::U16LiteralOutOfRange { span } => span.clone(),
226            ConvertParseTreeError::U32LiteralOutOfRange { span } => span.clone(),
227            ConvertParseTreeError::U64LiteralOutOfRange { span } => span.clone(),
228            ConvertParseTreeError::SignedIntegersNotSupported { span } => span.clone(),
229            ConvertParseTreeError::RefVariablesNotSupported { span } => span.clone(),
230            ConvertParseTreeError::LiteralPatternsNotSupportedHere { span } => span.clone(),
231            ConvertParseTreeError::ConstantPatternsNotSupportedHere { span } => span.clone(),
232            ConvertParseTreeError::ConstructorPatternsNotSupportedHere { span } => span.clone(),
233            ConvertParseTreeError::StructPatternsNotSupportedHere { span } => span.clone(),
234            ConvertParseTreeError::WildcardPatternsNotSupportedHere { span } => span.clone(),
235            ConvertParseTreeError::OrPatternsNotSupportedHere { span } => span.clone(),
236            ConvertParseTreeError::TuplePatternsNotSupportedHere { span } => span.clone(),
237            ConvertParseTreeError::RefPatternsNotSupportedHere { span } => span.clone(),
238            ConvertParseTreeError::ConstructorPatternOneArg { span } => span.clone(),
239            ConvertParseTreeError::ConstructorPatternSubPatterns { span } => span.clone(),
240            ConvertParseTreeError::PathsNotSupportedHere { span } => span.clone(),
241            ConvertParseTreeError::FullySpecifiedTypesNotSupported { span } => span.clone(),
242            ConvertParseTreeError::ContractCallerOneGenericArg { span } => span.clone(),
243            ConvertParseTreeError::ContractCallerNamedTypeGenericArg { span } => span.clone(),
244            ConvertParseTreeError::ConstrainedNonExistentType { span, .. } => span.clone(),
245            ConvertParseTreeError::GetStorageKeyTooManyArgs { span, .. } => span.clone(),
246            ConvertParseTreeError::RecursiveType { span } => span.clone(),
247            ConvertParseTreeError::DuplicateEnumVariant { span, .. } => span.clone(),
248            ConvertParseTreeError::DuplicateStorageField { span, .. } => span.clone(),
249            ConvertParseTreeError::DuplicateConfigurable { span, .. } => span.clone(),
250            ConvertParseTreeError::MultipleConfigurableBlocksInModule { span } => span.clone(),
251            ConvertParseTreeError::DuplicateStructField { span, .. } => span.clone(),
252            ConvertParseTreeError::DuplicateParameterIdentifier { span, .. } => span.clone(),
253            ConvertParseTreeError::SelfParameterNotAllowedForFn { span, .. } => span.clone(),
254            ConvertParseTreeError::ExpectedModuleAtBeginning { span } => span.clone(),
255            ConvertParseTreeError::ConstantRequiresExpression { span } => span.clone(),
256            ConvertParseTreeError::ConstantRequiresTypeAscription { span } => span.clone(),
257            ConvertParseTreeError::UnknownTypeNameSelf { span } => span.clone(),
258            ConvertParseTreeError::InvalidAttributeTarget { span, .. } => span.clone(),
259            ConvertParseTreeError::InvalidAttributeMultiplicity {
260                last_occurrence: last_attribute,
261                ..
262            } => last_attribute.span(),
263            ConvertParseTreeError::InvalidAttributeArgsMultiplicity { span, .. } => span.clone(),
264            ConvertParseTreeError::InvalidAttributeArg { arg, .. } => arg.span(),
265            ConvertParseTreeError::InvalidAttributeArgExpectsValue { arg, .. } => arg.span(),
266            ConvertParseTreeError::InvalidAttributeArgValueType { span, .. } => span.clone(),
267            ConvertParseTreeError::InvalidAttributeArgValue { span, .. } => span.clone(),
268        }
269    }
270}
sway_error/convert_parse_tree_error.rs

sway_error/
convert_parse_tree_error.rs
