Introduce trybuild to test failing compilation

Cargo.toml

@@ -23,6 +23,7 @@ rust-version = "1.63.0"
 derive_arbitrary = { version = "1.1.6", path = "./derive", optional = true }
 
 [dev-dependencies]
+trybuild = { version = "1.0.71", features = ["diff"] }
 
 [features]
 # Turn this feature on to enable support for `#[derive(Arbitrary)]`.

derive/src/field_attributes.rs

@@ -30,22 +30,33 @@ pub fn determine_field_constructor(field: &Field) -> FieldConstructor {
 }
 
 fn fetch_attr_from_field(field: &Field) -> Option<&Attribute> {
-    field.attrs.iter().find(|a| {
-        let path = &a.path;
-        let name = quote!(#path).to_string();
-        name == ARBITRARY_ATTRIBUTE_NAME
-    })
+    let found_attributes: Vec<_> = field
+        .attrs
+        .iter()
+        .filter(|a| {
+            let path = &a.path;
+            let name = quote!(#path).to_string();
+            name == ARBITRARY_ATTRIBUTE_NAME
+        })
+        .collect();
+    if found_attributes.len() > 1 {
+        let name = field.ident.as_ref().unwrap();
+        panic!(
+            "Multiple conflicting #[{ARBITRARY_ATTRIBUTE_NAME}] attributes found on field `{name}`"
+        );
+    }
+    found_attributes.into_iter().next()
 }
 
 fn parse_attribute(attr: &Attribute) -> FieldConstructor {
     let group = {
         let mut tokens_iter = attr.clone().tokens.into_iter();
         let token = tokens_iter
             .next()
-            .unwrap_or_else(|| panic!("{ARBITRARY_ATTRIBUTE_NAME} attribute cannot be empty."));
+            .unwrap_or_else(|| panic!("#[{ARBITRARY_ATTRIBUTE_NAME}] cannot be empty."));
         match token {
             TokenTree::Group(g) => g,
-            t => panic!("{ARBITRARY_ATTRIBUTE_NAME} must contain a group, got: {t})"),
+            t => panic!("#[{ARBITRARY_ATTRIBUTE_NAME}] must contain a group, got: {t})"),
         }
     };
     parse_attribute_internals(group.stream())
@@ -55,31 +66,34 @@ fn parse_attribute_internals(stream: TokenStream) -> FieldConstructor {
     let mut tokens_iter = stream.into_iter();
     let token = tokens_iter
         .next()
-        .unwrap_or_else(|| panic!("{ARBITRARY_ATTRIBUTE_NAME} attribute cannot be empty."));
+        .unwrap_or_else(|| panic!("#[{ARBITRARY_ATTRIBUTE_NAME}] cannot be empty."));
     match token.to_string().as_ref() {
         "default" => FieldConstructor::Default,
         "with" => {
-            let func_path = parse_assigned_value(tokens_iter);
+            let func_path = parse_assigned_value("with", tokens_iter);
             FieldConstructor::WithFunction(func_path)
         }
         "value" => {
-            let value = parse_assigned_value(tokens_iter);
+            let value = parse_assigned_value("value", tokens_iter);
             FieldConstructor::Value(value)
         }
-        _ => panic!("Unknown options for {ARBITRARY_ATTRIBUTE_NAME}: {token}"),
+        _ => panic!("Unknown option for #[{ARBITRARY_ATTRIBUTE_NAME}]: `{token}`"),
     }
 }
 
 // Input:
-//     = "2 + 2"
+//     = 2 + 2
 // Output:
 //     2 + 2
-fn parse_assigned_value(mut tokens_iter: impl Iterator<Item = TokenTree>) -> TokenStream {
-    let eq_sign = tokens_iter
-        .next()
-        .unwrap_or_else(|| panic!("Invalid syntax for {ARBITRARY_ATTRIBUTE_NAME}() attribute"));
+fn parse_assigned_value(
+    opt_name: &str,
+    mut tokens_iter: impl Iterator<Item = TokenTree>,
+) -> TokenStream {
+    let eq_sign = tokens_iter.next().unwrap_or_else(|| {
+        panic!("Invalid syntax for #[{ARBITRARY_ATTRIBUTE_NAME}], `{opt_name}` is missing RHS.")
+    });
     if eq_sign.to_string() != "=" {
-        panic!("Invalid syntax for {ARBITRARY_ATTRIBUTE_NAME}() attribute");
+        panic!("Invalid syntax for #[{ARBITRARY_ATTRIBUTE_NAME}], expected `=` after `{opt_name}`, got: `{eq_sign}`");
     }
     tokens_iter.collect()
 }

tests/compiletest.rs

@@ -0,0 +1,5 @@
+#[test]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/**/*.rs");
+}

tests/ui/multiple_arbitrary.rs

@@ -0,0 +1,11 @@
+use arbitrary::Arbitrary;
+
+#[derive(Arbitrary)]
+struct Point {
+    #[arbitrary(value = 2)]
+    #[arbitrary(value = 3)]
+    x: i32,
+    y: i32
+}
+
+fn main() { }

tests/ui/multiple_arbitrary.stderr

@@ -0,0 +1,7 @@
+error: proc-macro derive panicked
+ --> tests/ui/multiple_arbitrary.rs:3:10
+  |
+3 | #[derive(Arbitrary)]
+  |          ^^^^^^^^^
+  |
+  = help: message: Multiple conflicting #[arbitrary] attributes found on field `x`

tests/ui/unknown_attribute.rs

@@ -0,0 +1,10 @@
+use arbitrary::Arbitrary;
+
+#[derive(Arbitrary)]
+struct Point {
+    #[arbitrary(unknown_attr)]
+    x: i32,
+    y: i32
+}
+
+fn main() { }

tests/ui/unknown_attribute.stderr

@@ -0,0 +1,7 @@
+error: proc-macro derive panicked
+ --> tests/ui/unknown_attribute.rs:3:10
+  |
+3 | #[derive(Arbitrary)]
+  |          ^^^^^^^^^
+  |
+  = help: message: Unknown option for #[arbitrary]: `unknown_attr`

tests/ui/unknown_attribute_with_value.rs

@@ -0,0 +1,10 @@
+use arbitrary::Arbitrary;
+
+#[derive(Arbitrary)]
+struct Point {
+    #[arbitrary(unknown_attr = 255)]
+    x: i32,
+    y: i32
+}
+
+fn main() { }

tests/ui/unknown_attribute_with_value.stderr

@@ -0,0 +1,7 @@
+error: proc-macro derive panicked
+ --> tests/ui/unknown_attribute_with_value.rs:3:10
+  |
+3 | #[derive(Arbitrary)]
+  |          ^^^^^^^^^
+  |
+  = help: message: Unknown option for #[arbitrary]: `unknown_attr`

tests/ui/value_no_rhs.rs

@@ -0,0 +1,10 @@
+use arbitrary::Arbitrary;
+
+#[derive(Arbitrary)]
+struct Point {
+    #[arbitrary(value)]
+    x: i32,
+    y: i32
+}
+
+fn main() { }

tests/ui/value_no_rhs.stderr

@@ -0,0 +1,7 @@
+error: proc-macro derive panicked
+ --> tests/ui/value_no_rhs.rs:3:10
+  |
+3 | #[derive(Arbitrary)]
+  |          ^^^^^^^^^
+  |
+  = help: message: Invalid syntax for #[arbitrary], `value` is missing RHS.

tests/ui/with_no_rhs.rs

@@ -0,0 +1,10 @@
+use arbitrary::Arbitrary;
+
+#[derive(Arbitrary)]
+struct Point {
+    #[arbitrary(with)]
+    x: i32,
+    y: i32
+}
+
+fn main() { }

tests/ui/with_no_rhs.stderr

@@ -0,0 +1,7 @@
+error: proc-macro derive panicked
+ --> tests/ui/with_no_rhs.rs:3:10
+  |
+3 | #[derive(Arbitrary)]
+  |          ^^^^^^^^^
+  |
+  = help: message: Invalid syntax for #[arbitrary], `with` is missing RHS.