feat!: make most structs non exhaustive and add builders (#25)

Author: beeb

Cargo.lock

@@ -13,6 +13,7 @@ version = "0.1.6"
 
 [dependencies]
 anyhow = "1.0.95"
+bon = "3.3.2"
 clap = { version = "4.5.29", features = ["derive"] }
 derive_more = { version = "2.0.1", features = ["from", "display"] }
 dotenvy = "0.15.7"

Cargo.toml

@@ -63,7 +63,9 @@ pub struct Args {
     pub compact: Option<bool>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(PathBuf, into))]
 pub struct Config {
     pub paths: Vec<PathBuf>,
     pub exclude: Vec<PathBuf>,

src/config.rs

@@ -12,7 +12,8 @@ use super::{
 };
 
 /// A constructor definition
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
 pub struct ConstructorDefinition {
     pub parent: Option<Parent>,
     pub span: TextRange,
@@ -94,3 +95,51 @@ impl Validate for ConstructorDefinition {
         out
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use semver::Version;
+    use slang_solidity::parser::Parser;
+
+    use super::*;
+
+    static OPTIONS: ValidationOptions = ValidationOptions {
+        inheritdoc: false,
+        constructor: true,
+        enum_params: false,
+    };
+
+    fn parse_file(contents: &str) -> ConstructorDefinition {
+        let parser = Parser::create(Version::new(0, 8, 0)).unwrap();
+        let output = parser.parse(NonterminalKind::SourceUnit, contents);
+        assert!(output.is_valid(), "{:?}", output.errors());
+        let cursor = output.create_tree_cursor();
+        let m = cursor
+            .query(vec![ConstructorDefinition::query()])
+            .next()
+            .unwrap();
+        let def = ConstructorDefinition::extract(m).unwrap();
+        def.as_constructor().unwrap()
+    }
+
+    #[test]
+    fn test_constructor() {
+        let contents = "contract Test {
+            /// @param param1 Test
+            /// @param param2 Test2
+            constructor(uint256 param1, bytes calldata param2) { } 
+        }";
+        let res = parse_file(contents).validate(&OPTIONS);
+        assert!(res.diags.is_empty(), "{:#?}", res.diags);
+    }
+
+    #[test]
+    fn test_constructor_no_natspec() {
+        let contents = "contract Test {
+            constructor(uint256 param1, bytes calldata param2) { } 
+        }";
+        let res = parse_file(contents).validate(&OPTIONS);
+        assert_eq!(res.diags.len(), 1);
+        assert_eq!(res.diags[0].message, "missing NatSpec");
+    }
+}

src/definitions/constructor.rs

@@ -12,7 +12,9 @@ use super::{
 };
 
 /// An enum definition
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct EnumDefinition {
     pub parent: Option<Parent>,
     pub name: String,

src/definitions/enumeration.rs

@@ -12,7 +12,9 @@ use super::{
 };
 
 /// An error definition
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct ErrorDefinition {
     pub parent: Option<Parent>,
     pub name: String,

src/definitions/error.rs

@@ -12,7 +12,9 @@ use super::{
 };
 
 /// An event definition
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct EventDefinition {
     pub parent: Option<Parent>,
     pub name: String,

src/definitions/event.rs

@@ -13,7 +13,9 @@ use super::{
 };
 
 /// A function definition
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct FunctionDefinition {
     pub parent: Option<Parent>,
     pub name: String,

src/definitions/function.rs

@@ -45,7 +45,8 @@ pub fn capture_opt(m: &QueryMatch, name: &str) -> Result<Option<Cursor>> {
 }
 
 /// Validation options to control which lints generate a diagnostic
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
 pub struct ValidationOptions {
     /// Whether overridden, public and external functions should have an `@inheritdoc`
     pub inheritdoc: bool,
@@ -105,7 +106,8 @@ pub trait Validate {
 /// An identifier (named or unnamed) and its span
 ///
 /// Unnamed identifiers are used for unnamed return params.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[builder(on(String, into))]
 pub struct Identifier {
     pub name: Option<String>,
     pub span: TextRange,
@@ -124,7 +126,8 @@ pub enum Visibility {
 }
 
 /// Attributes for a function or state variable (visibility and override)
-#[derive(Debug, Clone, Copy, Default)]
+#[derive(Debug, Clone, Copy, Default, bon::Builder)]
+#[non_exhaustive]
 pub struct Attributes {
     pub visibility: Visibility,
     pub r#override: bool,
@@ -185,6 +188,70 @@ impl Definition {
             Definition::Variable(def) => def.validate(options),
         }
     }
+
+    /// Retrieve the inner constructor definition
+    pub fn as_constructor(self) -> Option<ConstructorDefinition> {
+        match self {
+            Definition::Constructor(def) => Some(def),
+            _ => None,
+        }
+    }
+
+    /// Retrieve the inner enum definition
+    pub fn as_enum(self) -> Option<EnumDefinition> {
+        match self {
+            Definition::Enumeration(def) => Some(def),
+            _ => None,
+        }
+    }
+
+    /// Retrieve the inner error definition
+    pub fn as_error(self) -> Option<ErrorDefinition> {
+        match self {
+            Definition::Error(def) => Some(def),
+            _ => None,
+        }
+    }
+
+    /// Retrieve the inner event definition
+    pub fn as_event(self) -> Option<EventDefinition> {
+        match self {
+            Definition::Event(def) => Some(def),
+            _ => None,
+        }
+    }
+
+    /// Retrieve the inner function definition
+    pub fn as_function(self) -> Option<FunctionDefinition> {
+        match self {
+            Definition::Function(def) => Some(def),
+            _ => None,
+        }
+    }
+
+    /// Retrieve the inner modifier definition
+    pub fn as_modifier(self) -> Option<ModifierDefinition> {
+        match self {
+            Definition::Modifier(def) => Some(def),
+            _ => None,
+        }
+    }
+
+    /// Retrieve the inner struct definition
+    pub fn as_struct(self) -> Option<StructDefinition> {
+        match self {
+            Definition::Struct(def) => Some(def),
+            _ => None,
+        }
+    }
+
+    /// Retrieve the inner variable declaration
+    pub fn as_variable(self) -> Option<VariableDeclaration> {
+        match self {
+            Definition::Variable(def) => Some(def),
+            _ => None,
+        }
+    }
 }
 
 /// Find source item definitions from a root CST cursor

src/definitions/mod.rs

@@ -12,7 +12,9 @@ use super::{
 };
 
 /// A modifier definition
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct ModifierDefinition {
     pub parent: Option<Parent>,
     pub name: String,

src/definitions/modifier.rs

@@ -12,7 +12,9 @@ use super::{
 };
 
 /// A struct definition
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct StructDefinition {
     pub parent: Option<Parent>,
     pub name: String,

src/definitions/structure.rs

@@ -12,7 +12,9 @@ use super::{
 };
 
 /// A state variable declaration
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct VariableDeclaration {
     pub parent: Option<Parent>,
     pub name: String,

src/definitions/variable.rs

@@ -32,7 +32,9 @@ pub struct FileDiagnostics {
 }
 
 /// Diagnostics for a single source item (function, struct, etc.)
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct ItemDiagnostics {
     /// The parent contract, interface or library's name
     pub parent: Option<Parent>,

src/lint.rs

@@ -67,7 +67,9 @@ impl NatSpec {
 }
 
 /// A single NatSpec item
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, bon::Builder)]
+#[non_exhaustive]
+#[builder(on(String, into))]
 pub struct NatSpecItem {
     /// The kind of NatSpec (notice, dev, param, etc.)
     pub kind: NatSpecKind,