Added new errors

examples/partial.rs

@@ -12,6 +12,8 @@ pub trait A {
 		}: User,
 	) {
 	}
+
+	fn not_sealed();
 }
 
 pub struct Email(String);
@@ -25,18 +27,24 @@ pub struct User {
 pub struct Impl;
 
 #[sealed]
-impl A for Impl {}
+impl A for Impl {
+	fn not_sealed() {}
+}
 
 #[sealed(partial)]
 pub trait B {
 	#[seal(callable)]
-	fn no_default(email: Email);
+	fn no_default(_email: Email) {}
+
+	fn hello();
 }
 
 #[sealed]
 impl B for Impl {
 	#[seal(callable)]
 	fn no_default(_email: Email) {}
+
+	fn hello() {}
 }
 
 #[sealed]

src/lib.rs

@@ -158,6 +158,9 @@ fn parse_sealed_trait(mut item_trait: syn::ItemTrait, args: TraitArguments) -> T
 
 	let mut wrappers = Vec::<syn::TraitItem>::new();
 
+	let mut all_implementable = true;
+	let mut none_implementable = true;
+
 	for item in &mut item_trait.items {
 		if let syn::TraitItem::Fn(item) = item {
 			let input = match parse_function_arguments(&item.attrs) {
@@ -170,6 +173,7 @@ fn parse_sealed_trait(mut item_trait: syn::ItemTrait, args: TraitArguments) -> T
 			};
 
 			let Some((attr, input)) = input else {
+				none_implementable = false;
 				continue;
 			};
 
@@ -189,8 +193,20 @@ fn parse_sealed_trait(mut item_trait: syn::ItemTrait, args: TraitArguments) -> T
 						.into_compile_error()
 						.into()
 				}
-				Ok(Some(wrapper)) => wrappers.push(wrapper.into()),
-				Ok(None) => {}
+				Ok(_) if args.partial && item.default.is_none() => {
+					return syn::Error::new(
+						attr.span(), 
+						"This function is sealed from implementation, \
+							but it does not have a default implementation. \
+							This effectively seals the entire trait, \
+							which would be clearer to do by not having the trait seal be partial."
+						).into_compile_error().into()
+				}
+				Ok(Some(wrapper)) => {
+					all_implementable = false;
+					wrappers.push(wrapper.into())
+				},
+				Ok(None) => all_implementable = false,
 				Err(err) => {
 					return err
 						.into_compile_error()
@@ -200,6 +216,17 @@ fn parse_sealed_trait(mut item_trait: syn::ItemTrait, args: TraitArguments) -> T
 		}
 	}
 
+	if args.partial && all_implementable {
+		return syn::Error::new(item_trait.ident.span(), "This trait is partially sealed, \
+			however none of its methods are sealed, so it does nothing. \
+			Either seal a function or remove `partial` from the `sealed` attribute.").to_compile_error().into();
+	}
+
+	if args.partial && none_implementable {
+		return syn::Error::new(item_trait.ident.span(), "This trait is partially sealed, \
+		however none of its methods are implementable, so the `partial` argument does nothing.").into_compile_error().into();
+	}
+
 	item_trait
 		.items
 		.extend(wrappers);

tests/fail/09-partial-argument.rs

@@ -0,0 +1,14 @@
+use sealed::sealed;
+
+#[sealed(partial)]
+pub trait A {
+	#[seal]
+	fn sealed() {}
+}
+
+#[sealed(partial)]
+pub trait B {
+	fn not_sealed();
+}
+
+fn main() {}

tests/fail/09-partial-argument.stderr

@@ -0,0 +1,11 @@
+error: This trait is partially sealed, however none of its methods are implementable, so the `partial` argument does nothing.
+ --> tests/fail/09-partial-argument.rs:4:11
+  |
+4 | pub trait A {
+  |           ^
+
+error: This trait is partially sealed, however none of its methods are sealed, so it does nothing. Either seal a function or remove `partial` from the `sealed` attribute.
+  --> tests/fail/09-partial-argument.rs:10:11
+   |
+10 | pub trait B {
+   |           ^

tests/fail/10-partial-without-default.rs

@@ -0,0 +1,9 @@
+use sealed::sealed;
+
+#[sealed(partial)]
+pub trait A {
+	#[seal]
+	fn sealed();
+}
+
+fn main() {}

tests/fail/10-partial-without-default.stderr

@@ -0,0 +1,5 @@
+error: This function is sealed from implementation, but it does not have a default implementation. This effectively seals the entire trait, which would be clearer to do by not having the trait seal be partial.
+ --> tests/fail/10-partial-without-default.rs:5:2
+  |
+5 |     #[seal]
+  |     ^^^^^^^