refactor(definitions): replace macro with function (#24)

Author: beeb

flake.lock

@@ -45,8 +45,8 @@ impl Validate for ConstructorDefinition {
     }
 
     fn extract(m: QueryMatch) -> Result<Definition> {
-        let constructor = capture!(m, "constructor");
-        let params = capture!(m, "constructor_params");
+        let constructor = capture(&m, "constructor")?;
+        let params = capture(&m, "constructor_params")?;
 
         let span = params.text_range();
         let params = extract_params(params, NonterminalKind::Parameter);

src/definitions/constructor.rs

@@ -45,9 +45,9 @@ impl Validate for EnumDefinition {
     }
 
     fn extract(m: QueryMatch) -> Result<Definition> {
-        let enumeration = capture!(m, "enum");
-        let name = capture!(m, "enum_name");
-        let members = capture!(m, "enum_members");
+        let enumeration = capture(&m, "enum")?;
+        let name = capture(&m, "enum_name")?;
+        let members = capture(&m, "enum_members")?;
 
         let span = enumeration.text_range();
         let name = name.node().unparse().trim().to_string();

src/definitions/enumeration.rs

@@ -45,9 +45,9 @@ impl Validate for ErrorDefinition {
     }
 
     fn extract(m: QueryMatch) -> Result<Definition> {
-        let err = capture!(m, "err");
-        let name = capture!(m, "err_name");
-        let params = capture!(m, "err_params");
+        let err = capture(&m, "err")?;
+        let name = capture(&m, "err_name")?;
+        let params = capture(&m, "err_params")?;
 
         let span = err.text_range();
         let name = name.node().unparse().trim().to_string();

src/definitions/error.rs

@@ -45,9 +45,9 @@ impl Validate for EventDefinition {
     }
 
     fn extract(m: QueryMatch) -> Result<Definition> {
-        let event = capture!(m, "event");
-        let name = capture!(m, "event_name");
-        let params = capture!(m, "event_params");
+        let event = capture(&m, "event")?;
+        let name = capture(&m, "event_name")?;
+        let params = capture(&m, "event_params")?;
 
         let span = event.text_range();
         let name = name.node().unparse().trim().to_string();

src/definitions/event.rs

@@ -1,15 +1,15 @@
 use slang_solidity::cst::{NonterminalKind, Query, QueryMatch, TextRange};
 
 use crate::{
-    error::{Error, Result},
+    error::Result,
     lint::{Diagnostic, ItemDiagnostics, ItemType},
     natspec::{NatSpec, NatSpecKind},
 };
 
 use super::{
-    capture, check_params, check_returns, extract_attributes, extract_comment, extract_params,
-    extract_parent_name, Attributes, Definition, Identifier, Parent, Validate, ValidationOptions,
-    Visibility,
+    capture, capture_opt, check_params, check_returns, extract_attributes, extract_comment,
+    extract_params, extract_parent_name, Attributes, Definition, Identifier, Parent, Validate,
+    ValidationOptions, Visibility,
 };
 
 /// A function definition
@@ -70,19 +70,12 @@ impl Validate for FunctionDefinition {
     }
 
     fn extract(m: QueryMatch) -> Result<Definition> {
-        let func = capture!(m, "function");
-        let keyword = capture!(m, "keyword");
-        let name = capture!(m, "function_name");
-        let params = capture!(m, "function_params");
-        let attributes = capture!(m, "function_attr");
-        let returns = match m
-            .capture("function_returns")
-            .map(|(_, mut captures)| captures.next())
-        {
-            Some(Some(ret)) => Some(ret),
-            Some(None) => None,
-            _ => return Err(Error::UnknownError),
-        };
+        let func = capture(&m, "function")?;
+        let keyword = capture(&m, "keyword")?;
+        let name = capture(&m, "function_name")?;
+        let params = capture(&m, "function_params")?;
+        let attributes = capture(&m, "function_attr")?;
+        let returns = capture_opt(&m, "function_returns")?;
 
         let span = if let Some(returns) = &returns {
             keyword.text_range().start..returns.text_range().end

src/definitions/function.rs

@@ -28,18 +28,21 @@ pub mod structure;
 pub mod variable;
 
 /// Retrieve and unwrap the first capture of a parser match, or return with an [`Error`]
-macro_rules! capture {
-    ($m:ident, $name:expr) => {
-        match $m.capture($name).map(|(_, mut captures)| captures.next()) {
-            Some(Some(res)) => res,
-            _ => {
-                return Err($crate::error::Error::UnknownError);
-            }
-        }
-    };
+pub fn capture(m: &QueryMatch, name: &str) -> Result<Cursor> {
+    match m.capture(name).map(|(_, mut captures)| captures.next()) {
+        Some(Some(res)) => Ok(res),
+        _ => Err(Error::UnknownError),
+    }
 }
 
-pub(crate) use capture;
+/// Retrieve and unwrap the first capture of a parser match if one exists.
+pub fn capture_opt(m: &QueryMatch, name: &str) -> Result<Option<Cursor>> {
+    match m.capture(name).map(|(_, mut captures)| captures.next()) {
+        Some(Some(res)) => Ok(Some(res)),
+        Some(None) => Ok(None),
+        _ => Err(Error::UnknownError),
+    }
+}
 
 /// Validation options to control which lints generate a diagnostic
 #[derive(Debug, Clone)]

src/definitions/mod.rs

@@ -1,14 +1,14 @@
 use slang_solidity::cst::{NonterminalKind, Query, QueryMatch, TextRange};
 
 use crate::{
-    error::{Error, Result},
+    error::Result,
     lint::{Diagnostic, ItemDiagnostics, ItemType},
     natspec::{NatSpec, NatSpecKind},
 };
 
 use super::{
-    capture, check_params, extract_comment, extract_params, extract_parent_name, Definition,
-    Identifier, Parent, Validate, ValidationOptions,
+    capture, capture_opt, check_params, extract_comment, extract_params, extract_parent_name,
+    Definition, Identifier, Parent, Validate, ValidationOptions,
 };
 
 /// A modifier definition
@@ -48,17 +48,10 @@ impl Validate for ModifierDefinition {
     }
 
     fn extract(m: QueryMatch) -> Result<Definition> {
-        let modifier = capture!(m, "modifier");
-        let name = capture!(m, "modifier_name");
-        let params = match m
-            .capture("modifier_params")
-            .map(|(_, mut captures)| captures.next())
-        {
-            Some(Some(ret)) => Some(ret),
-            Some(None) => None,
-            _ => return Err(Error::UnknownError),
-        };
-        let attr = capture!(m, "modifier_attr");
+        let modifier = capture(&m, "modifier")?;
+        let name = capture(&m, "modifier_name")?;
+        let params = capture_opt(&m, "modifier_params")?;
+        let attr = capture(&m, "modifier_attr")?;
 
         let span = if let Some(params) = &params {
             name.text_range().start..params.text_range().end

src/definitions/modifier.rs

@@ -45,9 +45,9 @@ impl Validate for StructDefinition {
     }
 
     fn extract(m: QueryMatch) -> Result<Definition> {
-        let structure = capture!(m, "struct");
-        let name = capture!(m, "struct_name");
-        let members = capture!(m, "struct_members");
+        let structure = capture(&m, "struct")?;
+        let name = capture(&m, "struct_name")?;
+        let members = capture(&m, "struct_members")?;
 
         let span = structure.text_range();
         let name = name.node().unparse().trim().to_string();
@@ -96,7 +96,7 @@ fn extract_struct_members(cursor: Cursor) -> Result<Vec<Identifier>> {
     )
     .expect("query should compile");
     for m in cursor.query(vec![query]) {
-        let member_name = capture!(m, "member_name");
+        let member_name = capture(&m, "member_name")?;
         out.push(Identifier {
             name: Some(member_name.node().unparse().trim().to_string()),
             span: member_name.text_range(),

src/definitions/structure.rs

@@ -54,10 +54,10 @@ impl Validate for VariableDeclaration {
     }
 
     fn extract(m: QueryMatch) -> Result<Definition> {
-        let variable = capture!(m, "variable");
-        let var_type = capture!(m, "variable_type");
-        let attributes = capture!(m, "variable_attr");
-        let name = capture!(m, "variable_name");
+        let variable = capture(&m, "variable")?;
+        let var_type = capture(&m, "variable_type")?;
+        let attributes = capture(&m, "variable_attr")?;
+        let name = capture(&m, "variable_name")?;
 
         let span = var_type.text_range().start..variable.text_range().end;
         let name = name.node().unparse().trim().to_string();