aldrin_parser/error/
duplicate_definition.rs

1use super::Error;
2use crate::ast::Ident;
3use crate::diag::{Diagnostic, DiagnosticKind, Formatted, Formatter};
4use crate::validate::Validate;
5use crate::{util, Parsed, Schema, Span};
6
7#[derive(Debug)]
8pub struct DuplicateDefinition {
9    schema_name: String,
10    duplicate: Ident,
11    first: Span,
12}
13
14impl DuplicateDefinition {
15    pub(crate) fn validate(schema: &Schema, validate: &mut Validate) {
16        util::find_duplicates(
17            schema.definitions(),
18            |def| def.name().value(),
19            |duplicate, first| {
20                validate.add_error(Self {
21                    schema_name: validate.schema_name().to_owned(),
22                    duplicate: duplicate.name().clone(),
23                    first: first.name().span(),
24                });
25            },
26        );
27    }
28
29    pub fn duplicate(&self) -> &Ident {
30        &self.duplicate
31    }
32
33    pub fn first(&self) -> Span {
34        self.first
35    }
36}
37
38impl Diagnostic for DuplicateDefinition {
39    fn kind(&self) -> DiagnosticKind {
40        DiagnosticKind::Error
41    }
42
43    fn schema_name(&self) -> &str {
44        &self.schema_name
45    }
46
47    fn format<'a>(&'a self, parsed: &'a Parsed) -> Formatted<'a> {
48        let mut fmt = Formatter::new(
49            self,
50            format!("duplicate definition `{}`", self.duplicate.value()),
51        );
52
53        if let Some(schema) = parsed.get_schema(&self.schema_name) {
54            fmt.main_block(
55                schema,
56                self.duplicate.span().from,
57                self.duplicate.span(),
58                "duplicate definition",
59            );
60            fmt.info_block(schema, self.first.from, self.first, "first defined here");
61        }
62
63        fmt.format()
64    }
65}
66
67impl From<DuplicateDefinition> for Error {
68    fn from(e: DuplicateDefinition) -> Self {
69        Self::DuplicateDefinition(e)
70    }
71}