1mod const_int_not_found;
2mod duplicate_definition;
3mod duplicate_enum_variant;
4mod duplicate_enum_variant_id;
5mod duplicate_event_id;
6mod duplicate_function_id;
7mod duplicate_service_item;
8mod duplicate_service_uuid;
9mod duplicate_struct_field;
10mod duplicate_struct_field_id;
11mod empty_enum;
12mod expected_const_int_found_service;
13mod expected_const_int_found_string;
14mod expected_const_int_found_type;
15mod expected_const_int_found_uuid;
16mod expected_type_found_const;
17mod expected_type_found_service;
18mod import_not_found;
19mod invalid_array_len;
20mod invalid_const_value;
21mod invalid_enum_variant_id;
22mod invalid_escape_code;
23mod invalid_event_id;
24mod invalid_function_id;
25mod invalid_ident;
26mod invalid_key_type;
27mod invalid_schema_name;
28mod invalid_service_version;
29mod invalid_struct_field_id;
30mod invalid_syntax;
31mod io_error;
32mod missing_import;
33mod recursive_type;
34mod type_not_found;
35
36use crate::diag::{Diagnostic, DiagnosticKind, Renderer};
37use crate::Parser;
38
39pub(crate) use const_int_not_found::ConstIntNotFound;
40pub(crate) use duplicate_definition::DuplicateDefinition;
41pub(crate) use duplicate_enum_variant::DuplicateEnumVariant;
42pub(crate) use duplicate_enum_variant_id::DuplicateEnumVariantId;
43pub(crate) use duplicate_event_id::DuplicateEventId;
44pub(crate) use duplicate_function_id::DuplicateFunctionId;
45pub(crate) use duplicate_service_item::DuplicateServiceItem;
46pub(crate) use duplicate_service_uuid::DuplicateServiceUuid;
47pub(crate) use duplicate_struct_field::DuplicateStructField;
48pub(crate) use duplicate_struct_field_id::DuplicateStructFieldId;
49pub(crate) use empty_enum::EmptyEnum;
50pub(crate) use expected_const_int_found_service::ExpectedConstIntFoundService;
51pub(crate) use expected_const_int_found_string::ExpectedConstIntFoundString;
52pub(crate) use expected_const_int_found_type::ExpectedConstIntFoundType;
53pub(crate) use expected_const_int_found_uuid::ExpectedConstIntFoundUuid;
54pub(crate) use expected_type_found_const::ExpectedTypeFoundConst;
55pub(crate) use expected_type_found_service::ExpectedTypeFoundService;
56pub(crate) use import_not_found::ImportNotFound;
57pub(crate) use invalid_array_len::InvalidArrayLen;
58pub(crate) use invalid_const_value::InvalidConstValue;
59pub(crate) use invalid_enum_variant_id::InvalidEnumVariantId;
60pub(crate) use invalid_escape_code::InvalidEscapeCode;
61pub(crate) use invalid_event_id::InvalidEventId;
62pub(crate) use invalid_function_id::InvalidFunctionId;
63pub(crate) use invalid_ident::InvalidIdent;
64pub(crate) use invalid_key_type::InvalidKeyType;
65pub(crate) use invalid_schema_name::InvalidSchemaName;
66pub(crate) use invalid_service_version::InvalidServiceVersion;
67pub(crate) use invalid_struct_field_id::InvalidStructFieldId;
68pub(crate) use invalid_syntax::InvalidSyntax;
69pub(crate) use io_error::IoError;
70pub(crate) use missing_import::MissingImport;
71pub(crate) use recursive_type::{RecursiveEnum, RecursiveNewtype, RecursiveStruct};
72pub(crate) use type_not_found::TypeNotFound;
73
74#[derive(Debug)]
75pub struct Error {
76 kind: ErrorKind,
77}
78
79impl Error {
80 pub(crate) fn error_kind(&self) -> &ErrorKind {
81 &self.kind
82 }
83}
84
85impl Diagnostic for Error {
86 fn kind(&self) -> DiagnosticKind {
87 DiagnosticKind::Error
88 }
89
90 fn schema_name(&self) -> &str {
91 self.kind.schema_name()
92 }
93
94 fn render(&self, renderer: &Renderer, parser: &Parser) -> String {
95 self.kind.render(renderer, parser)
96 }
97}
98
99#[derive(Debug)]
100pub(crate) enum ErrorKind {
101 ConstIntNotFound(ConstIntNotFound),
102 DuplicateDefinition(DuplicateDefinition),
103 DuplicateEnumVariant(DuplicateEnumVariant),
104 DuplicateEnumVariantId(DuplicateEnumVariantId),
105 DuplicateEventId(DuplicateEventId),
106 DuplicateFunctionId(DuplicateFunctionId),
107 DuplicateServiceItem(DuplicateServiceItem),
108 DuplicateServiceUuid(DuplicateServiceUuid),
109 DuplicateStructField(DuplicateStructField),
110 DuplicateStructFieldId(DuplicateStructFieldId),
111 EmptyEnum(EmptyEnum),
112 ExpectedConstIntFoundService(ExpectedConstIntFoundService),
113 ExpectedConstIntFoundString(ExpectedConstIntFoundString),
114 ExpectedConstIntFoundType(ExpectedConstIntFoundType),
115 ExpectedConstIntFoundUuid(ExpectedConstIntFoundUuid),
116 ExpectedTypeFoundConst(ExpectedTypeFoundConst),
117 ExpectedTypeFoundService(ExpectedTypeFoundService),
118 ImportNotFound(ImportNotFound),
119 InvalidArrayLen(InvalidArrayLen),
120 InvalidConstValue(InvalidConstValue),
121 InvalidEnumVariantId(InvalidEnumVariantId),
122 InvalidEscapeCode(InvalidEscapeCode),
123 InvalidEventId(InvalidEventId),
124 InvalidFunctionId(InvalidFunctionId),
125 InvalidIdent(InvalidIdent),
126 InvalidKeyType(InvalidKeyType),
127 InvalidSchemaName(InvalidSchemaName),
128 InvalidServiceVersion(InvalidServiceVersion),
129 InvalidStructFieldId(InvalidStructFieldId),
130 InvalidSyntax(InvalidSyntax),
131 IoError(IoError),
132 MissingImport(MissingImport),
133 RecursiveEnum(RecursiveEnum),
134 RecursiveNewtype(RecursiveNewtype),
135 RecursiveStruct(RecursiveStruct),
136 TypeNotFound(TypeNotFound),
137}
138
139impl Diagnostic for ErrorKind {
140 fn kind(&self) -> DiagnosticKind {
141 DiagnosticKind::Error
142 }
143
144 fn schema_name(&self) -> &str {
145 match self {
146 Self::ConstIntNotFound(e) => e.schema_name(),
147 Self::DuplicateDefinition(e) => e.schema_name(),
148 Self::DuplicateEnumVariant(e) => e.schema_name(),
149 Self::DuplicateEnumVariantId(e) => e.schema_name(),
150 Self::DuplicateEventId(e) => e.schema_name(),
151 Self::DuplicateFunctionId(e) => e.schema_name(),
152 Self::DuplicateServiceItem(e) => e.schema_name(),
153 Self::DuplicateServiceUuid(e) => e.schema_name(),
154 Self::DuplicateStructField(e) => e.schema_name(),
155 Self::DuplicateStructFieldId(e) => e.schema_name(),
156 Self::EmptyEnum(e) => e.schema_name(),
157 Self::ExpectedConstIntFoundService(e) => e.schema_name(),
158 Self::ExpectedConstIntFoundString(e) => e.schema_name(),
159 Self::ExpectedConstIntFoundType(e) => e.schema_name(),
160 Self::ExpectedConstIntFoundUuid(e) => e.schema_name(),
161 Self::ExpectedTypeFoundConst(e) => e.schema_name(),
162 Self::ExpectedTypeFoundService(e) => e.schema_name(),
163 Self::ImportNotFound(e) => e.schema_name(),
164 Self::InvalidArrayLen(e) => e.schema_name(),
165 Self::InvalidConstValue(e) => e.schema_name(),
166 Self::InvalidEnumVariantId(e) => e.schema_name(),
167 Self::InvalidEscapeCode(e) => e.schema_name(),
168 Self::InvalidEventId(e) => e.schema_name(),
169 Self::InvalidFunctionId(e) => e.schema_name(),
170 Self::InvalidIdent(e) => e.schema_name(),
171 Self::InvalidKeyType(e) => e.schema_name(),
172 Self::InvalidSchemaName(e) => e.schema_name(),
173 Self::InvalidServiceVersion(e) => e.schema_name(),
174 Self::InvalidStructFieldId(e) => e.schema_name(),
175 Self::InvalidSyntax(e) => e.schema_name(),
176 Self::IoError(e) => e.schema_name(),
177 Self::MissingImport(e) => e.schema_name(),
178 Self::RecursiveEnum(e) => e.schema_name(),
179 Self::RecursiveNewtype(e) => e.schema_name(),
180 Self::RecursiveStruct(e) => e.schema_name(),
181 Self::TypeNotFound(e) => e.schema_name(),
182 }
183 }
184
185 fn render(&self, renderer: &Renderer, parser: &Parser) -> String {
186 match self {
187 Self::ConstIntNotFound(e) => e.render(renderer, parser),
188 Self::DuplicateDefinition(e) => e.render(renderer, parser),
189 Self::DuplicateEnumVariant(e) => e.render(renderer, parser),
190 Self::DuplicateEnumVariantId(e) => e.render(renderer, parser),
191 Self::DuplicateEventId(e) => e.render(renderer, parser),
192 Self::DuplicateFunctionId(e) => e.render(renderer, parser),
193 Self::DuplicateServiceItem(e) => e.render(renderer, parser),
194 Self::DuplicateServiceUuid(e) => e.render(renderer, parser),
195 Self::DuplicateStructField(e) => e.render(renderer, parser),
196 Self::DuplicateStructFieldId(e) => e.render(renderer, parser),
197 Self::EmptyEnum(e) => e.render(renderer, parser),
198 Self::ExpectedConstIntFoundService(e) => e.render(renderer, parser),
199 Self::ExpectedConstIntFoundString(e) => e.render(renderer, parser),
200 Self::ExpectedConstIntFoundType(e) => e.render(renderer, parser),
201 Self::ExpectedConstIntFoundUuid(e) => e.render(renderer, parser),
202 Self::ExpectedTypeFoundConst(e) => e.render(renderer, parser),
203 Self::ExpectedTypeFoundService(e) => e.render(renderer, parser),
204 Self::ImportNotFound(e) => e.render(renderer, parser),
205 Self::InvalidArrayLen(e) => e.render(renderer, parser),
206 Self::InvalidConstValue(e) => e.render(renderer, parser),
207 Self::InvalidEnumVariantId(e) => e.render(renderer, parser),
208 Self::InvalidEscapeCode(e) => e.render(renderer, parser),
209 Self::InvalidEventId(e) => e.render(renderer, parser),
210 Self::InvalidFunctionId(e) => e.render(renderer, parser),
211 Self::InvalidIdent(e) => e.render(renderer, parser),
212 Self::InvalidKeyType(e) => e.render(renderer, parser),
213 Self::InvalidSchemaName(e) => e.render(renderer, parser),
214 Self::InvalidServiceVersion(e) => e.render(renderer, parser),
215 Self::InvalidStructFieldId(e) => e.render(renderer, parser),
216 Self::InvalidSyntax(e) => e.render(renderer, parser),
217 Self::IoError(e) => e.render(renderer, parser),
218 Self::MissingImport(e) => e.render(renderer, parser),
219 Self::RecursiveEnum(e) => e.render(renderer, parser),
220 Self::RecursiveNewtype(e) => e.render(renderer, parser),
221 Self::RecursiveStruct(e) => e.render(renderer, parser),
222 Self::TypeNotFound(e) => e.render(renderer, parser),
223 }
224 }
225}