Extend error message

crates/macro/src/html_tree/html_component.rs

@@ -6,6 +6,7 @@ use boolinator::Boolinator;
 use proc_macro2::Span;
 use quote::{quote, quote_spanned, ToTokens};
 use std::cmp::Ordering;
+use std::collections::HashMap;
 use syn::buffer::Cursor;
 use syn::parse;
 use syn::parse::{Parse, ParseStream, Result as ParseResult};
@@ -359,6 +360,9 @@ impl Props {
             Props::None => None,
         }
     }
+    fn collision_message() -> &'static str {
+        "Using special syntax `with props` along with named prop is not allowed. This rule does not apply to special `ref` prop"
+    }
 }
 
 impl PeekValue<PropType> for Props {
@@ -388,28 +392,93 @@ struct ListProps {
     props: Vec<HtmlProp>,
     node_ref: Option<Expr>,
 }
-
-impl Parse for ListProps {
-    fn parse(input: ParseStream) -> ParseResult<Self> {
+impl ListProps {
+    fn collect_props(input: ParseStream) -> ParseResult<Vec<HtmlProp>> {
         let mut props: Vec<HtmlProp> = Vec::new();
         while HtmlProp::peek(input.cursor()).is_some() {
             props.push(input.parse::<HtmlProp>()?);
         }
+        Ok(props)
+    }
 
+    fn remove_refs(mut props: Vec<HtmlProp>) -> ListProps {
         let ref_position = props.iter().position(|p| p.label.to_string() == "ref");
         let node_ref = ref_position.map(|i| props.remove(i).value);
-        for prop in &props {
+        ListProps { props, node_ref }
+    }
+
+    fn apply_edge_cases(props: &Vec<HtmlProp>, cases: &[&str]) -> Result<(), syn::Error> {
+        let mut map: HashMap<&str, Box<dyn Fn(&HtmlProp) -> Result<_, syn::Error>>> =
+            HashMap::new();
+
+        let ref_handler = |prop: &HtmlProp| -> Result<_, syn::Error> {
             if prop.label.to_string() == "ref" {
-                return Err(syn::Error::new_spanned(&prop.label, "too many refs set"));
+                Err(syn::Error::new_spanned(&prop.label, "too many refs set"))
+            } else {
+                Ok(())
             }
+        };
+
+        let type_handler = |prop: &HtmlProp| -> Result<_, syn::Error> {
             if prop.label.to_string() == "type" {
-                return Err(syn::Error::new_spanned(&prop.label, "expected identifier"));
+                Err(syn::Error::new_spanned(&prop.label, "expected identifier"))
+            } else {
+                Ok(())
             }
+        };
+
+        let unexpected_handler = |prop: &HtmlProp| -> Result<_, syn::Error> {
             if !prop.label.extended.is_empty() {
-                return Err(syn::Error::new_spanned(&prop.label, "expected identifier"));
+                Err(syn::Error::new_spanned(&prop.label, "expected identifier"))
+            } else {
+                Ok(())
+            }
+        };
+
+        map.insert("ref", Box::new(ref_handler));
+        map.insert("type", Box::new(type_handler));
+        map.insert("unexpected", Box::new(unexpected_handler));
+
+        let errors = props.iter().fold(vec![], |acc, prop: &HtmlProp| {
+            [
+                acc,
+                cases
+                    .iter()
+                    .map(|elem| match map.get(elem) {
+                        Some(handler) => handler(prop),
+                        None => Err(syn::Error::new_spanned(&prop.label, "something went wrong")),
+                    })
+                    .filter(Result::is_err)
+                    .collect::<Vec<Result<_, syn::Error>>>(),
+            ]
+            .concat()
+        });
+
+        for error in errors {
+            return error;
+        }
+
+        Ok(())
+    }
+}
+
+impl Parse for ListProps {
+    fn parse(input: ParseStream) -> ParseResult<Self> {
+        let props = ListProps::collect_props(input)?;
+
+        if let Some(ident) = input.cursor().ident() {
+            if ident.0 == "with" {
+                return Err(input.error(Props::collision_message()));
             }
         }
 
+        let ListProps {
+            mut props,
+            node_ref,
+        } = ListProps::remove_refs(props);
+
+        ListProps::apply_edge_cases(&props, &["ref"])?;
+
         // alphabetize
         props.sort_by(|a, b| {
             if a.label == b.label {
@@ -442,16 +511,27 @@ impl Parse for WithProps {
             return Err(input.error("expected to find `with` token"));
         }
         let props = input.parse::<Ident>()?;
+
         let _ = input.parse::<Token![,]>();
 
         // Check for the ref tag after `with`
         let mut node_ref = None;
-        if let Some(ident) = input.cursor().ident() {
-            let prop = input.parse::<HtmlProp>()?;
-            if ident.0 == "ref" {
-                node_ref = Some(prop.value);
-            } else {
-                return Err(syn::Error::new_spanned(&prop.label, "unexpected token"));
+        if input.cursor().ident().is_some() {
+            let ListProps {
+                props: list_props,
+                node_ref: reference,
+            } = ListProps::remove_refs(ListProps::collect_props(input)?);
+            node_ref = reference;
+
+            for prop in &list_props {
+                if prop.label.to_string() == "ref" {
+                    return Err(syn::Error::new_spanned(&prop.label, "too many refs set"));
+                } else {
+                    return Err(syn::Error::new_spanned(
+                        &prop.label,
+                        Props::collision_message(),
+                    ));
+                }
             }
         }
 

tests/macro/html-component-fail.rs

@@ -56,9 +56,17 @@ fn compile_fail() {
     html! { <Child props /> };
     html! { <Child with props > };
     html! { <Child with props ref=() ref=() /> };
+    html! { <Child with props ref=() ref=() value=1 /> };
+    html! { <Child with props ref=() value=1 ref=() /> };
+    html! { <Child with props value=1 ref=()  ref=() /> };
+    html! { <Child value=1 with props  ref=()  ref=() /> };
+    html! { <Child value=1 ref=() with props ref=() /> };
+    html! { <Child ref=() ref=() value=1  with props  /> };
     html! { <Child ref=() with props /> };
     html! { <Child with blah /> };
     html! { <Child with props () /> };
+    html! { <Child value=1 with props /> };
+    html! { <Child with props value=1 /> };
     html! { <Child type=0 /> };
     html! { <Child invalid-prop-name=0 /> };
     html! { <Child unknown="unknown" /> };