1use sway_types::{Ident, Span, Spanned};
2use thiserror::Error;
3
4#[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
5pub enum ConvertParseTreeError {
6 #[error("Imports without items are not supported")]
7 ImportsWithoutItemsNotSupported { span: Span },
8 #[error("functions used in applications may not be arbitrary expressions")]
9 FunctionArbitraryExpression { span: Span },
10 #[error("generics are not supported here")]
11 GenericsNotSupportedHere { span: Span },
12 #[error("multiple generics are not supported")]
13 MultipleGenericsNotSupported { span: Span },
14 #[error("tuple index out of range")]
15 TupleIndexOutOfRange { span: Span },
16 #[error("shift-left expressions are not implemented")]
17 ShlNotImplemented { span: Span },
18 #[error("shift-right expressions are not implemented")]
19 ShrNotImplemented { span: Span },
20 #[error("bitwise xor expressions are not implemented")]
21 BitXorNotImplemented { span: Span },
22 #[error("integer literals in this position cannot have a type suffix")]
23 IntTySuffixNotSupported { span: Span },
24 #[error("int literal out of range")]
25 IntLiteralOutOfRange { span: Span },
26 #[error("expected an integer literal")]
27 IntLiteralExpected { span: Span },
28 #[error("qualified path roots are not implemented")]
29 QualifiedPathRootsNotImplemented { span: Span },
30 #[error("char literals are not implemented")]
31 CharLiteralsNotImplemented { span: Span },
32 #[error("hex literals must have 1..16 or 64 digits")]
33 HexLiteralLength { span: Span },
34 #[error("binary literals must have either 1..64 or 256 digits")]
35 BinaryLiteralLength { span: Span },
36 #[error("u8 literal out of range")]
37 U8LiteralOutOfRange { span: Span },
38 #[error("u16 literal out of range")]
39 U16LiteralOutOfRange { span: Span },
40 #[error("u32 literal out of range")]
41 U32LiteralOutOfRange { span: Span },
42 #[error("u64 literal out of range")]
43 U64LiteralOutOfRange { span: Span },
44 #[error("signed integers are not supported")]
45 SignedIntegersNotSupported { span: Span },
46 #[error("ref variables are not supported")]
47 RefVariablesNotSupported { span: Span },
48 #[error("literal patterns not supported in this position")]
49 LiteralPatternsNotSupportedHere { span: Span },
50 #[error("constant patterns not supported in this position")]
51 ConstantPatternsNotSupportedHere { span: Span },
52 #[error("constructor patterns not supported in this position")]
53 ConstructorPatternsNotSupportedHere { span: Span },
54 #[error("struct patterns not supported in this position")]
55 StructPatternsNotSupportedHere { span: Span },
56 #[error("wildcard patterns not supported in this position")]
57 WildcardPatternsNotSupportedHere { span: Span },
58 #[error("or patterns not supported in this position")]
59 OrPatternsNotSupportedHere { span: Span },
60 #[error("tuple patterns not supported in this position")]
61 TuplePatternsNotSupportedHere { span: Span },
62 #[error("ref patterns not supported in this position")]
63 RefPatternsNotSupportedHere { span: Span },
64 #[error("constructor patterns require a single argument")]
65 ConstructorPatternOneArg { span: Span },
66 #[error("constructor patterns cannot contain sub-patterns")]
67 ConstructorPatternSubPatterns { span: Span },
68 #[error("paths are not supported in this position")]
69 PathsNotSupportedHere { span: Span },
70 #[error("Fully specified types are not supported in this position. Try importing the type and referring to it here.")]
71 FullySpecifiedTypesNotSupported { span: Span },
72 #[error("ContractCaller requires exactly one generic argument")]
73 ContractCallerOneGenericArg { span: Span },
74 #[error("ContractCaller requires a named type for its generic argument")]
75 ContractCallerNamedTypeGenericArg { span: Span },
76 #[error("invalid argument for '{attribute}' attribute")]
77 InvalidAttributeArgument { attribute: String, span: Span },
78 #[error("cannot find type \"{ty_name}\" in this scope")]
79 ConstrainedNonExistentType { ty_name: Ident, span: Span },
80 #[error("__get_storage_key does not take arguments")]
81 GetStorageKeyTooManyArgs { span: Span },
82 #[error("recursive types are not supported")]
83 RecursiveType { span: Span },
84 #[error("enum variant \"{name}\" already declared")]
85 DuplicateEnumVariant { name: Ident, span: Span },
86 #[error("storage field \"{name}\" already declared")]
87 DuplicateStorageField { name: Ident, span: Span },
88 #[error("configurable \"{name}\" already declared")]
89 DuplicateConfigurable { name: Ident, span: Span },
90 #[error("Multiple configurable blocks detected in this module")]
91 MultipleConfigurableBlocksInModule { span: Span },
92 #[error("struct field \"{name}\" already declared")]
93 DuplicateStructField { name: Ident, span: Span },
94 #[error("identifier \"{name}\" bound more than once in this parameter list")]
95 DuplicateParameterIdentifier { name: Ident, span: Span },
96 #[error("self parameter is not allowed for {fn_kind}")]
97 SelfParameterNotAllowedForFn { fn_kind: String, span: Span },
98 #[error("test functions are only allowed at module level")]
99 TestFnOnlyAllowedAtModuleLevel { span: Span },
100 #[error("`impl Self` for contracts is not supported")]
101 SelfImplForContract { span: Span },
102 #[error("Cannot attach a documentation comment to a dependency.")]
103 CannotDocCommentDependency { span: Span },
104 #[error("Cannot annotate a dependency.")]
105 CannotAnnotateDependency { span: Span },
106 #[error("Expected dependency at the beginning before any other items.")]
107 ExpectedDependencyAtBeginning { span: Span },
108 #[error("Constant requires expression.")]
109 ConstantRequiresExpression { span: Span },
110 #[error("Constant requires type ascription.")]
111 ConstantRequiresTypeAscription { span: Span },
112 #[error("Invalid value \"{value}\"")]
113 InvalidCfgTargetArgValue { span: Span, value: String },
114 #[error("Expected a value for the target argument")]
115 ExpectedCfgTargetArgValue { span: Span },
116 #[error("Invalid value \"{value}\"")]
117 InvalidCfgProgramTypeArgValue { span: Span, value: String },
118 #[error("Expected a value for the program_type argument")]
119 ExpectedCfgProgramTypeArgValue { span: Span },
120 #[error("Expected \"true\" or \"false\" for experimental conditional compilation")]
121 UnexpectedValueForCfgExperimental { span: Span },
122 #[error("Unexpected attribute value: \"{value}\" for attribute: \"cfg\"")]
123 InvalidCfgArg { span: Span, value: String },
124 #[error("Unknown type name \"self\". A self type with a similar name exists (notice the capitalization): `Self`")]
125 UnknownTypeNameSelf { span: Span },
126}
127
128impl Spanned for ConvertParseTreeError {
129 fn span(&self) -> Span {
130 match self {
131 ConvertParseTreeError::ImportsWithoutItemsNotSupported { span } => span.clone(),
132 ConvertParseTreeError::FunctionArbitraryExpression { span } => span.clone(),
133 ConvertParseTreeError::GenericsNotSupportedHere { span } => span.clone(),
134 ConvertParseTreeError::MultipleGenericsNotSupported { span } => span.clone(),
135 ConvertParseTreeError::TupleIndexOutOfRange { span } => span.clone(),
136 ConvertParseTreeError::ShlNotImplemented { span } => span.clone(),
137 ConvertParseTreeError::ShrNotImplemented { span } => span.clone(),
138 ConvertParseTreeError::BitXorNotImplemented { span } => span.clone(),
139 ConvertParseTreeError::IntTySuffixNotSupported { span } => span.clone(),
140 ConvertParseTreeError::IntLiteralOutOfRange { span } => span.clone(),
141 ConvertParseTreeError::IntLiteralExpected { span } => span.clone(),
142 ConvertParseTreeError::QualifiedPathRootsNotImplemented { span } => span.clone(),
143 ConvertParseTreeError::CharLiteralsNotImplemented { span } => span.clone(),
144 ConvertParseTreeError::HexLiteralLength { span } => span.clone(),
145 ConvertParseTreeError::BinaryLiteralLength { span } => span.clone(),
146 ConvertParseTreeError::U8LiteralOutOfRange { span } => span.clone(),
147 ConvertParseTreeError::U16LiteralOutOfRange { span } => span.clone(),
148 ConvertParseTreeError::U32LiteralOutOfRange { span } => span.clone(),
149 ConvertParseTreeError::U64LiteralOutOfRange { span } => span.clone(),
150 ConvertParseTreeError::SignedIntegersNotSupported { span } => span.clone(),
151 ConvertParseTreeError::RefVariablesNotSupported { span } => span.clone(),
152 ConvertParseTreeError::LiteralPatternsNotSupportedHere { span } => span.clone(),
153 ConvertParseTreeError::ConstantPatternsNotSupportedHere { span } => span.clone(),
154 ConvertParseTreeError::ConstructorPatternsNotSupportedHere { span } => span.clone(),
155 ConvertParseTreeError::StructPatternsNotSupportedHere { span } => span.clone(),
156 ConvertParseTreeError::WildcardPatternsNotSupportedHere { span } => span.clone(),
157 ConvertParseTreeError::OrPatternsNotSupportedHere { span } => span.clone(),
158 ConvertParseTreeError::TuplePatternsNotSupportedHere { span } => span.clone(),
159 ConvertParseTreeError::RefPatternsNotSupportedHere { span } => span.clone(),
160 ConvertParseTreeError::ConstructorPatternOneArg { span } => span.clone(),
161 ConvertParseTreeError::ConstructorPatternSubPatterns { span } => span.clone(),
162 ConvertParseTreeError::PathsNotSupportedHere { span } => span.clone(),
163 ConvertParseTreeError::FullySpecifiedTypesNotSupported { span } => span.clone(),
164 ConvertParseTreeError::ContractCallerOneGenericArg { span } => span.clone(),
165 ConvertParseTreeError::ContractCallerNamedTypeGenericArg { span } => span.clone(),
166 ConvertParseTreeError::InvalidAttributeArgument { span, .. } => span.clone(),
167 ConvertParseTreeError::ConstrainedNonExistentType { span, .. } => span.clone(),
168 ConvertParseTreeError::GetStorageKeyTooManyArgs { span, .. } => span.clone(),
169 ConvertParseTreeError::RecursiveType { span } => span.clone(),
170 ConvertParseTreeError::DuplicateEnumVariant { span, .. } => span.clone(),
171 ConvertParseTreeError::DuplicateStorageField { span, .. } => span.clone(),
172 ConvertParseTreeError::DuplicateConfigurable { span, .. } => span.clone(),
173 ConvertParseTreeError::MultipleConfigurableBlocksInModule { span } => span.clone(),
174 ConvertParseTreeError::DuplicateStructField { span, .. } => span.clone(),
175 ConvertParseTreeError::DuplicateParameterIdentifier { span, .. } => span.clone(),
176 ConvertParseTreeError::SelfParameterNotAllowedForFn { span, .. } => span.clone(),
177 ConvertParseTreeError::TestFnOnlyAllowedAtModuleLevel { span } => span.clone(),
178 ConvertParseTreeError::SelfImplForContract { span, .. } => span.clone(),
179 ConvertParseTreeError::CannotDocCommentDependency { span } => span.clone(),
180 ConvertParseTreeError::CannotAnnotateDependency { span } => span.clone(),
181 ConvertParseTreeError::ExpectedDependencyAtBeginning { span } => span.clone(),
182 ConvertParseTreeError::ConstantRequiresExpression { span } => span.clone(),
183 ConvertParseTreeError::ConstantRequiresTypeAscription { span } => span.clone(),
184 ConvertParseTreeError::InvalidCfgTargetArgValue { span, .. } => span.clone(),
185 ConvertParseTreeError::ExpectedCfgTargetArgValue { span } => span.clone(),
186 ConvertParseTreeError::InvalidCfgProgramTypeArgValue { span, .. } => span.clone(),
187 ConvertParseTreeError::ExpectedCfgProgramTypeArgValue { span } => span.clone(),
188 ConvertParseTreeError::UnexpectedValueForCfgExperimental { span } => span.clone(),
189 ConvertParseTreeError::InvalidCfgArg { span, .. } => span.clone(),
190 ConvertParseTreeError::UnknownTypeNameSelf { span } => span.clone(),
191 }
192 }
193}