Add UI tests and more comments to procedural macro

Author: bytesnake

tests/tests/expand/simple-struct.rs

@@ -0,0 +1,9 @@
+use tsap::param;
+
+#[param]
+#[derive(Debug)]
+struct SingleField<const C: bool> {
+    value: f32,
+}
+
+fn main() {}

tests/tests/ui/missing-const-generic.rs

@@ -0,0 +1,8 @@
+use tsap::param;
+
+#[param]
+struct Param {
+    no_const: u32
+}
+
+fn main() {}

tests/tests/ui/missing-const-generic.stderr

@@ -0,0 +1,10 @@
+error: parameter sets should have a const boolean to indicate checking
+
+         = help: add a const boolean as your first generic
+
+ --> tests/ui/missing-const-generic.rs:4:1
+  |
+4 | / struct Param {
+5 | |     no_const: u32
+6 | | }
+  | |_^

tests/tests/ui/multiple-enum-fields.rs

@@ -0,0 +1,8 @@
+use tsap::param;
+
+#[param]
+enum Param<const C: bool> {
+    NotSupported(f32, f32)
+}
+
+fn main() {}

tests/tests/ui/multiple-enum-fields.stderr

@@ -0,0 +1,10 @@
+error: we don't support variants with more than one field
+
+         = help: `#[params]' can only be used on enum with single field variants
+
+ --> tests/ui/multiple-enum-fields.rs:4:1
+  |
+4 | / enum Param<const C: bool> {
+5 | |     NotSupported(f32, f32)
+6 | | }
+  | |_^

tests/tests/ui/named-enum-field.rs

@@ -0,0 +1,10 @@
+use tsap::param;
+
+#[param]
+enum Param<const C: bool> {
+    NotSupported {
+        value: f32,
+    }
+}
+
+fn main() {}

tests/tests/ui/named-enum-field.stderr

@@ -0,0 +1,10 @@
+error: named enum variants are not supported
+
+         = help: use unnamed variant
+
+ --> tests/ui/named-enum-field.rs:5:5
+  |
+5 | /     NotSupported {
+6 | |         value: f32,
+7 | |     }
+  | |_____^

tests/tests/ui/other-type-argument-first.rs

@@ -0,0 +1,15 @@
+use tsap::param;
+
+#[param]
+enum Param<'a, const C: bool> {
+    RandomForest,
+    SVClassifier
+}
+
+#[param]
+enum Param<T, const C: bool> {
+    RandomForest(T),
+    SVClassifier
+}
+
+fn main() {}

tests/tests/ui/other-type-argument-first.stderr

@@ -0,0 +1,23 @@
+error: parameter sets should have a const boolean to indicate checking
+
+         = help: add a const boolean as your first generic
+
+ --> tests/ui/other-type-argument-first.rs:4:1
+  |
+4 | / enum Param<'a, const C: bool> {
+5 | |     RandomForest,
+6 | |     SVClassifier
+7 | | }
+  | |_^
+
+error: parameter sets should have a const boolean to indicate checking
+
+         = help: add a const boolean as your first generic
+
+  --> tests/ui/other-type-argument-first.rs:10:1
+   |
+10 | / enum Param<T, const C: bool> {
+11 | |     RandomForest(T),
+12 | |     SVClassifier
+13 | | }
+   | |_^

tests/tests/ui/some-arguments.rs

@@ -0,0 +1,8 @@
+use tsap::param;
+
+#[param(should_not_have = "this")]
+struct Param<const C: bool> {
+    no_const: u32
+}
+
+fn main() {}

tests/tests/ui/some-arguments.stderr

@@ -0,0 +1,8 @@
+error: this attribute takes no arguments
+
+         = help: use #[param]
+
+ --> tests/ui/some-arguments.rs:3:9
+  |
+3 | #[param(should_not_have = "this")]
+  |         ^^^^^^^^^^^^^^^^^^^^^^^^

tests/tests/ui/trait-not-allowed.rs

@@ -0,0 +1,8 @@
+use tsap::param;
+
+#[param]
+trait Param<const C: bool> {
+    type Assoc;
+}
+
+fn main() {}

tests/tests/ui/trait-not-allowed.stderr

@@ -0,0 +1,10 @@
+error: item is not a struct or enum
+
+         = help: `#[params]` can only be used on structs or enums
+
+ --> tests/ui/trait-not-allowed.rs:4:1
+  |
+4 | / trait Param<const C: bool> {
+5 | |     type Assoc;
+6 | | }
+  | |_^

tsap/src/templates.rs

@@ -84,7 +84,7 @@ impl Template for RunCommand {
 pub struct GlobPattern;
 
 impl Template for GlobPattern {
-    fn resolve(&mut self, key: String, _map: Table, field: toml::Value) -> Value {
+    fn resolve(&mut self, _key: String, _map: Table, field: toml::Value) -> Value {
         let pattern = match field {
             Value::String(cmd) => cmd,
             _ => panic!("Glob pattern not a string!"),

tsap/src/toml_builder.rs

@@ -16,7 +16,7 @@ fn merge(mut root: Value, action: Action) -> (Value, Vec<Action>) {
     let num = paths.len() - 1;
 
     for path in &paths[..=num-1] {
-        let local = match local {
+        match local {
             Value::Table(ref mut t) if t.contains_key(path) =>
                 local = t.get_mut(path).unwrap(),
             _ => return (root, vec![action])
@@ -170,7 +170,7 @@ impl TryFrom<toml::Value> for TomlBuilder {
     type Error = Error;
 
     fn try_from(root: toml::Value) -> Result<TomlBuilder> {
-        let mut builder = TomlBuilder {
+        let builder = TomlBuilder {
             templates: Templates::default(),
             actions: Vec::new(),
             root,

tsap_macro/src/lib.rs

@@ -20,7 +20,6 @@ pub fn param(args: TokenStream, input: TokenStream) -> TokenStream {
     let item = parser::parse(args.into(), input.clone().into());
     let model = model::analyze(item);
     let ir = lower::Intermediate::lower(model.clone());
-    let tokens = quote!(#ir);
 
     #[cfg(feature="toml")]
     let res = {

tsap_macro/src/lower.rs

@@ -1,4 +1,4 @@
-use syn::{Item, Ident};
+use syn::Ident;
 use proc_macro2::TokenStream;
 use quote::{quote, format_ident};
 

tsap_macro/src/lower_toml.rs

@@ -5,15 +5,14 @@ use crate::model::{Model, ModelFields};
 #[derive(Debug)]
 pub struct Intermediate {
     pub(crate) item: TokenStream,
-    pub(crate) builder: TokenStream,
     pub(crate) impls: TokenStream,
 }
 
 impl Intermediate {
     pub(crate) fn lower(model: Model) -> Intermediate {
         let item2 = model.item_definition(Some(false));
 
-        let Model { name, check_name, item, fields, .. } = model;
+        let Model { name, fields, .. } = model;
 
         let builder_name = format_ident!("{}Builder", name);
         let builder = quote!(
@@ -35,7 +34,6 @@ impl Intermediate {
             let valname = format!("{}", name);
             let typ = typ.as_ref().unwrap();
             let arg_typ_false = typ.quote(Some(false));
-            let arg_typ = typ.quote(None);
 
             quote!(
                 fn #name<F: FnOnce(#arg_typ_false) -> #arg_typ_false>(mut self, val: F) -> Self {
@@ -119,7 +117,6 @@ impl Intermediate {
 
         Intermediate {
             item,
-            builder: builder,
             impls: impls,
         }
     }

tsap_macro/src/model.rs

@@ -1,4 +1,4 @@
-use syn::{Item, Ident, Type, Fields, GenericParam, FieldsUnnamed, PathArguments, AngleBracketedGenericArguments, GenericArgument, TypePath, punctuated::Punctuated, token::{Comma, Colon2}, PathSegment, TypeTraitObject, TypeParamBound, visit::{self, Visit}, visit_mut::{self, VisitMut}};
+use syn::{Item, Ident, Type, Fields, GenericParam, FieldsUnnamed, punctuated::Punctuated, token::Comma, PathSegment, visit::{self, Visit}, visit_mut::{self, VisitMut}};
 use proc_macro_error::abort;
 use quote::quote;
 use proc_macro2::{TokenStream, Span};
@@ -33,30 +33,37 @@ impl VisitMut for ReplaceCheck {
     }
 }
 
+/// Type of a field, either named in struct or unnamed in enums
+///
+/// Carries information whether we want to track check status of wrapped type
+/// in `const_name` optionality.
 #[derive(Debug, Clone)]
 pub struct ModelType {
     wrapped: Type,
     const_name: Option<Ident>,
 }
 
 impl ModelType {
+    /// Construct a field type with const generic parameter
+    ///
+    /// Checks if const generic parameter exists in the wrapped type
     pub fn new(typ: &Type, const_name: &Ident) -> ModelType {
         let mut visitor = FindCheck { found: false, const_name };
         visitor.visit_type(typ);
 
-        if visitor.found {
-            ModelType {
-                wrapped: typ.clone(),
-                const_name: Some(const_name.clone()),
-            }
-        } else {
-            ModelType {
-                wrapped: typ.clone(),
-                const_name: None,
-            }
+        let const_name = match visitor.found {
+            true => Some(const_name.clone()),
+            false => None,
+        };
+
+        ModelType {
+            wrapped: typ.clone(),
+            const_name,
         }
     }
 
+    /// Create a token stream from the type and fills in definitions of const
+    /// generic parameter
     pub fn quote(&self, checked: Option<bool>) -> TokenStream {
         if let Some(const_name) = &self.const_name {
             let check_param = match checked {
@@ -77,11 +84,18 @@ impl ModelType {
         }
     }
 
+    /// Contains const generic in field type
     pub fn has_const_name(&self) -> bool {
         self.const_name.is_some()
     }
 }
 
+/// Fields of annotated structures
+///
+/// We only support single, unnamed field in enum variants and named structure 
+/// fields. For named enum variants the inner definition should go in a separate
+/// struct. For unnamed struct variants no useful composition function names can
+/// be derived. Traits are not supported.
 #[derive(Debug, Clone)]
 pub enum ModelFields {
     Enum(Vec<(Ident, Option<ModelType>)>),
@@ -98,6 +112,7 @@ pub struct Model {
 }
 
 impl Model {
+    /// Return argument parameters of item
     pub(crate) fn param_args(&self) -> Punctuated<Ident, Comma> {
         self.rem_param_types.iter()
             .map(|x| match x {
@@ -108,6 +123,7 @@ impl Model {
             .collect()
     }
 
+    /// Return item definition with filled-in checked parameter
     pub(crate) fn item_definition(&self, checked: Option<bool>) -> TokenStream {
         let check_param = match checked {
             Some(true) => Ident::new("true", Span::call_site()),