feat: ensure uniqueness of all module declarations

Verify that all declared elements within a module (including the schema root which is a module itself) have a unique name so they can't collide.
dnaka91 · Oct 27, 2023 · d09e182 · d09e182
1 parent b43e779
commit d09e182
Show file tree

Hide file tree

Showing 34 changed files with 360 additions and 62 deletions.
diff --git a/crates/stef-build/src/decode.rs b/crates/stef-build/src/decode.rs
@@ -11,7 +11,7 @@ pub fn compile_struct(
         fields,
     }: &Struct<'_>,
 ) -> TokenStream {
-    let name = Ident::new(name, Span::call_site());
+    let name = Ident::new(name.get(), Span::call_site());
     let (generics, generics_where) = compile_generics(generics);
     let field_vars = compile_field_vars(fields);
     let field_matches = compile_field_matches(fields);
@@ -55,7 +55,7 @@ pub fn compile_enum(
         variants,
     }: &Enum<'_>,
 ) -> TokenStream {
-    let name = Ident::new(name, Span::call_site());
+    let name = Ident::new(name.get(), Span::call_site());
     let (generics, generics_where) = compile_generics(generics);
     let variants = variants.iter().map(compile_variant);
 

diff --git a/crates/stef-build/src/definition.rs b/crates/stef-build/src/definition.rs
@@ -59,7 +59,7 @@ fn compile_module(
     }: &Module<'_>,
 ) -> TokenStream {
     let comment = compile_comment(comment);
-    let name = Ident::new(name, Span::call_site());
+    let name = Ident::new(name.get(), Span::call_site());
     let definitions = definitions.iter().map(compile_definition);
 
     quote! {
@@ -83,7 +83,7 @@ fn compile_struct(
     }: &Struct<'_>,
 ) -> TokenStream {
     let comment = compile_comment(comment);
-    let name = Ident::new(name, Span::call_site());
+    let name = Ident::new(name.get(), Span::call_site());
     let generics = compile_generics(generics);
     let fields = compile_fields(fields, true);
 
@@ -105,7 +105,7 @@ fn compile_enum(
     }: &Enum<'_>,
 ) -> TokenStream {
     let comment = compile_comment(comment);
-    let name = Ident::new(name, Span::call_site());
+    let name = Ident::new(name.get(), Span::call_site());
     let generics = compile_generics(generics);
     let variants = variants.iter().map(compile_variant);
 
@@ -165,7 +165,7 @@ fn compile_const(
     }: &Const<'_>,
 ) -> TokenStream {
     let comment = compile_comment(comment);
-    let name = Ident::new(name, Span::call_site());
+    let name = Ident::new(name.get(), Span::call_site());
     let ty = compile_const_data_type(ty);
     let value = compile_literal(value);
 
@@ -185,8 +185,8 @@ fn compile_import(Import { segments, element }: &Import<'_>) -> TokenStream {
             quote! {#segment}
         }
     });
-    let element = element.map(|element| {
-        let element = Ident::new(element, Span::call_site());
+    let element = element.as_ref().map(|element| {
+        let element = Ident::new(element.get(), Span::call_site());
         quote! { ::#element}
     });
 

diff --git a/crates/stef-build/src/encode.rs b/crates/stef-build/src/encode.rs
@@ -11,7 +11,7 @@ pub fn compile_struct(
         fields,
     }: &Struct<'_>,
 ) -> TokenStream {
-    let name = Ident::new(name, Span::call_site());
+    let name = Ident::new(name.get(), Span::call_site());
     let (generics, generics_where) = compile_generics(generics);
     let fields = compile_struct_fields(fields);
 
@@ -94,7 +94,7 @@ pub fn compile_enum(
         variants,
     }: &Enum<'_>,
 ) -> TokenStream {
-    let name = Ident::new(name, Span::call_site());
+    let name = Ident::new(name.get(), Span::call_site());
     let (generics, generics_where) = compile_generics(generics);
     let variants = variants.iter().map(compile_variant);
 

diff --git a/crates/stef-compiler/src/lib.rs b/crates/stef-compiler/src/lib.rs
@@ -43,12 +43,14 @@ impl From<DuplicateFieldName> for Error {
 }
 
 pub fn validate_schema(value: &Schema<'_>) -> Result<(), Error> {
+    names::validate_names_in_module(&value.definitions)?;
     value.definitions.iter().try_for_each(validate_definition)
 }
 
 fn validate_definition(value: &Definition<'_>) -> Result<(), Error> {
     match value {
         Definition::Module(m) => {
+            names::validate_names_in_module(&m.definitions)?;
             m.definitions.iter().try_for_each(validate_definition)?;
         }
         Definition::Struct(s) => {

diff --git a/crates/stef-compiler/src/names.rs b/crates/stef-compiler/src/names.rs
@@ -1,7 +1,7 @@
 use std::{collections::HashMap, ops::Range};
 
 use miette::Diagnostic;
-use stef_parser::{Enum, Fields, Spanned, Struct};
+use stef_parser::{Definition, Enum, Fields, Import, Spanned, Struct};
 use thiserror::Error;
 
 #[derive(Debug, Diagnostic, Error)]
@@ -12,6 +12,9 @@ pub enum DuplicateName {
     #[error("duplicate name in a field")]
     #[diagnostic(transparent)]
     Field(#[from] DuplicateFieldName),
+    #[error("duplicate name in the scope of a module")]
+    #[diagnostic(transparent)]
+    InModule(#[from] DuplicateNameInModule),
 }
 
 #[derive(Debug, Diagnostic, Error)]
@@ -36,6 +39,19 @@ pub struct DuplicateFieldName {
     pub second: Range<usize>,
 }
 
+#[derive(Debug, Diagnostic, Error)]
+#[error("duplicate definition name `{name}`")]
+#[diagnostic(help(
+    "the names of each definition must be unique and not collide with other declarations"
+))]
+pub struct DuplicateNameInModule {
+    pub name: String,
+    #[label("first declared here")]
+    pub first: Range<usize>,
+    #[label("used here again")]
+    pub second: Range<usize>,
+}
+
 /// Ensure all field names inside a struct are unique.
 pub(crate) fn validate_struct_names(value: &Struct<'_>) -> Result<(), DuplicateFieldName> {
     validate_field_names(&value.fields)
@@ -91,3 +107,35 @@ fn validate_field_names(value: &Fields<'_>) -> Result<(), DuplicateFieldName> {
 
     Ok(())
 }
+
+pub(crate) fn validate_names_in_module(value: &[Definition<'_>]) -> Result<(), DuplicateName> {
+    let mut visited = HashMap::with_capacity(value.len());
+    value
+        .iter()
+        .find_map(|definition| {
+            let name = match definition {
+                Definition::Module(m) => &m.name,
+                Definition::Struct(s) => &s.name,
+                Definition::Enum(e) => &e.name,
+                Definition::TypeAlias(_) => {
+                    eprintln!("TODO: implement name check for type aliases");
+                    return None;
+                }
+                Definition::Const(c) => &c.name,
+                Definition::Import(Import {
+                    element: Some(name),
+                    ..
+                }) => name,
+                Definition::Import(_) => return None,
+            };
+            visited.insert(name.get(), name.span()).map(|first| {
+                DuplicateNameInModule {
+                    name: name.get().to_owned(),
+                    first: first.into(),
+                    second: name.span().into(),
+                }
+                .into()
+            })
+        })
+        .map_or(Ok(()), Err)
+}
diff --git a/crates/stef-parser/src/lib.rs b/crates/stef-parser/src/lib.rs
@@ -207,7 +207,7 @@ pub struct Module<'a> {
     /// Optional module-level comment.
     pub comment: Comment<'a>,
     /// Unique name of the module, within the current scope.
-    pub name: &'a str,
+    pub name: Name<'a>,
     /// List of definitions that are scoped within this module.
     pub definitions: Vec<Definition<'a>>,
 }
@@ -264,7 +264,7 @@ pub struct Struct<'a> {
     /// Optional attributes to customize the behavior.
     pub attributes: Attributes<'a>,
     /// Unique name for this struct (within its scope).
-    pub name: &'a str,
+    pub name: Name<'a>,
     /// Potential generics.
     pub generics: Generics<'a>,
     /// Fields of the struct, if any.
@@ -318,7 +318,7 @@ pub struct Enum<'a> {
     /// Optional attributes to customize the behavior.
     pub attributes: Attributes<'a>,
     /// Unique name for this enum, within its current scope.
-    pub name: &'a str,
+    pub name: Name<'a>,
     /// Potential generics.
     pub generics: Generics<'a>,
     /// List of possible variants that the enum can represent.
@@ -895,7 +895,7 @@ pub struct Const<'a> {
     /// Optional element-level comment.
     pub comment: Comment<'a>,
     /// Unique identifier of this constant.
-    pub name: &'a str,
+    pub name: Name<'a>,
     /// Type of the value.
     pub ty: DataType<'a>,
     /// Literal value that this declaration represents.
@@ -952,7 +952,7 @@ pub struct Import<'a> {
     pub segments: Vec<&'a str>,
     /// Optional final element that allows to fully import the type, making it look as it would be
     /// defined in the current schema.
-    pub element: Option<&'a str>,
+    pub element: Option<Name<'a>>,
 }
 
 impl<'a> Print for Import<'a> {

diff --git a/crates/stef-parser/src/parser/consts.rs b/crates/stef-parser/src/parser/consts.rs
@@ -11,7 +11,7 @@ use winnow::{
 };
 
 use super::{literals, types, Input, ParserExt, Result};
-use crate::{highlight, location, Comment, Const};
+use crate::{highlight, location, Comment, Const, Name};
 
 /// Encountered an invalid `const` declaration.
 #[derive(Debug, ParserError)]
@@ -105,13 +105,18 @@ pub(super) fn parse<'i>(input: &mut Input<'i>) -> Result<Const<'i>, ParseError>
     })
 }
 
-pub(super) fn parse_name<'i>(input: &mut Input<'i>) -> Result<&'i str, Cause> {
+pub(super) fn parse_name<'i>(input: &mut Input<'i>) -> Result<Name<'i>, Cause> {
     (
         one_of('A'..='Z'),
         take_while(0.., ('A'..='Z', '0'..='9', '_')),
     )
         .recognize()
+        .with_span()
         .parse_next(input)
+        .map(|(value, span)| Name {
+            value,
+            span: span.into(),
+        })
         .map_err(|e| {
             e.map(|()| Cause::InvalidName {
                 at: input.location(),

diff --git a/crates/stef-parser/src/parser/enums.rs b/crates/stef-parser/src/parser/enums.rs
@@ -11,7 +11,7 @@ use winnow::{
 };
 
 use super::{comments, fields, generics, ids, ws, Input, ParserExt, Result};
-use crate::{highlight, Attributes, Comment, Enum, Variant};
+use crate::{highlight, Attributes, Comment, Enum, Name, Variant};
 
 /// Encountered an invalid `enum` declaration.
 #[derive(Debug, ParserError)]
@@ -109,10 +109,15 @@ pub(super) fn parse<'i>(input: &mut Input<'i>) -> Result<Enum<'i>, ParseError> {
     })
 }
 
-pub(super) fn parse_name<'i>(input: &mut Input<'i>) -> Result<&'i str, Cause> {
+pub(super) fn parse_name<'i>(input: &mut Input<'i>) -> Result<Name<'i>, Cause> {
     (one_of('A'..='Z'), alphanumeric0)
         .recognize()
+        .with_span()
         .parse_next(input)
+        .map(|(value, span)| Name {
+            value,
+            span: span.into(),
+        })
         .map_err(|e| {
             e.map(|()| Cause::InvalidName {
                 at: input.location(),

diff --git a/crates/stef-parser/src/parser/modules.rs b/crates/stef-parser/src/parser/modules.rs
@@ -11,7 +11,7 @@ use winnow::{
 };
 
 use super::{parse_definition, ws, Input, ParserExt, Result};
-use crate::{error::ParseDefinitionError, highlight, location, Comment, Module};
+use crate::{error::ParseDefinitionError, highlight, location, Comment, Module, Name};
 
 /// Encountered an invalid `mod` declaration.
 #[derive(Debug, ParserError)]
@@ -89,13 +89,18 @@ pub(super) fn parse<'i>(input: &mut Input<'i>) -> Result<Module<'i>, ParseError>
     })
 }
 
-fn parse_name<'i>(input: &mut Input<'i>) -> Result<&'i str, Cause> {
+fn parse_name<'i>(input: &mut Input<'i>) -> Result<Name<'i>, Cause> {
     (
         one_of('a'..='z'),
         take_while(0.., ('a'..='z', '0'..='9', '_')),
     )
         .recognize()
+        .with_span()
         .parse_next(input)
+        .map(|(value, span)| Name {
+            value,
+            span: span.into(),
+        })
         .map_err(|e| {
             e.map(|()| Cause::InvalidName {
                 at: input.location(),

diff --git a/crates/stef-parser/src/parser/structs.rs b/crates/stef-parser/src/parser/structs.rs
@@ -11,7 +11,7 @@ use winnow::{
 };
 
 use super::{fields, generics, Input, ParserExt, Result};
-use crate::{highlight, location, Attributes, Comment, Struct};
+use crate::{highlight, location, Attributes, Comment, Name, Struct};
 
 /// Encountered an invalid `struct` declaration.
 #[derive(Debug, ParserError)]
@@ -89,10 +89,15 @@ pub(super) fn parse<'i>(input: &mut Input<'i>) -> Result<Struct<'i>, ParseError>
     })
 }
 
-pub(super) fn parse_name<'i>(input: &mut Input<'i>) -> Result<&'i str, Cause> {
+pub(super) fn parse_name<'i>(input: &mut Input<'i>) -> Result<Name<'i>, Cause> {
     (one_of('A'..='Z'), alphanumeric0)
         .recognize()
+        .with_span()
         .parse_next(input)
+        .map(|(value, span)| Name {
+            value,
+            span: span.into(),
+        })
         .map_err(|e| {
             e.map(|()| Cause::InvalidName {
                 at: input.location(),

diff --git a/crates/stef-parser/tests/snapshots/parser__parse@attribute_multi.stef.snap b/crates/stef-parser/tests/snapshots/parser__parse@attribute_multi.stef.snap
@@ -37,7 +37,13 @@ Schema {
                         },
                     ],
                 ),
-                name: "Sample",
+                name: Name {
+                    value: "Sample",
+                    span: Span {
+                        start: 39,
+                        end: 45,
+                    },
+                },
                 generics: Generics(
                     [],
                 ),

diff --git a/crates/stef-parser/tests/snapshots/parser__parse@attribute_single.stef.snap b/crates/stef-parser/tests/snapshots/parser__parse@attribute_single.stef.snap
@@ -22,7 +22,13 @@ Schema {
                         },
                     ],
                 ),
-                name: "Sample",
+                name: Name {
+                    value: "Sample",
+                    span: Span {
+                        start: 35,
+                        end: 41,
+                    },
+                },
                 generics: Generics(
                     [],
                 ),

diff --git a/crates/stef-parser/tests/snapshots/parser__parse@attribute_unit.stef.snap b/crates/stef-parser/tests/snapshots/parser__parse@attribute_unit.stef.snap
@@ -18,7 +18,13 @@ Schema {
                         },
                     ],
                 ),
-                name: "Sample",
+                name: Name {
+                    value: "Sample",
+                    span: Span {
+                        start: 21,
+                        end: 27,
+                    },
+                },
                 generics: Generics(
                     [],
                 ),

diff --git a/crates/stef-parser/tests/snapshots/parser__parse@attributes.stef.snap b/crates/stef-parser/tests/snapshots/parser__parse@attributes.stef.snap
@@ -60,7 +60,13 @@ Schema {
                         },
                     ],
                 ),
-                name: "Sample",
+                name: Name {
+                    value: "Sample",
+                    span: Span {
+                        start: 111,
+                        end: 117,
+                    },
+                },
                 generics: Generics(
                     [],
                 ),