case by case

Author: kayagokalp

forc-pkg/src/pkg.rs

@@ -2046,17 +2046,17 @@ impl PkgTestEntry {
 
         // With fixture-based testing, #[test] is mandatory and can coexist with #[fuzz] and #[case]
         let has_case = test_function_decl.attributes.cases().next().is_some();
-        match (test_attr, fuzz_attr, has_case) {
-            (None, Some(_), _) | (None, None, true) => {
-                bail!(
-                    "Function \"{}\" has parameterization attributes (#[fuzz] or #[case]) but is missing the required #[test] attribute",
-                    test_function_decl.name
-                );
-            }
-            (None, None, false) => {
-                unreachable!("`test_function_decl` is guaranteed to be a test or fuzz function and it must have a `#[test]` attribute or parameterization attributes");
-            }
-            _ => {} // Valid: #[test] is present or only #[test] is present
+        let has_parameterization = fuzz_attr.is_some() || has_case;
+        
+        if test_attr.is_none() && has_parameterization {
+            bail!(
+                "Function \"{}\" has parameterization attributes (#[fuzz] or #[case]) but is missing the required #[test] attribute",
+                test_function_decl.name
+            );
+        }
+        
+        if test_attr.is_none() && !has_parameterization {
+            unreachable!("`test_function_decl` is guaranteed to be a test or fuzz function and it must have a `#[test]` attribute or parameterization attributes");
         }
 
         let pass_condition = if let Some(test_attr) = test_attr {

sway-core/src/lib.rs

@@ -218,42 +218,42 @@ pub(crate) fn attr_decls_to_attributes(
             let first_doc_line = attributes
                 .next()
                 .expect("`chunk_by` guarantees existence of at least one element in the chunk");
-            if !can_annotate(first_doc_line) {
-                let last_doc_line = match attributes.last() {
-                    Some(last_attr) => last_attr,
-                    // There is only one doc line in the complete doc comment.
-                    None => first_doc_line,
-                };
+            if can_annotate(first_doc_line) {
+                continue;
+            }
+
+            let last_doc_line = attributes.last().unwrap_or(first_doc_line);
+            handler.emit_err(
+                ConvertParseTreeError::InvalidAttributeTarget {
+                    span: Span::join(
+                        first_doc_line.span.clone(),
+                        &last_doc_line.span.start_span(),
+                    ),
+                    attribute: first_doc_line.name.clone(),
+                    target_friendly_name,
+                    can_only_annotate_help: first_doc_line
+                        .can_only_annotate_help(target_friendly_name),
+                }
+                .into(),
+            );
+        } else {
+            // For other attributes, the error is shown for every individual attribute.
+            for attribute in attributes {
+                if can_annotate(attribute) {
+                    continue;
+                }
+                
                 handler.emit_err(
                     ConvertParseTreeError::InvalidAttributeTarget {
-                        span: Span::join(
-                            first_doc_line.span.clone(),
-                            &last_doc_line.span.start_span(),
-                        ),
-                        attribute: first_doc_line.name.clone(),
+                        span: attribute.name.span(),
+                        attribute: attribute.name.clone(),
                         target_friendly_name,
-                        can_only_annotate_help: first_doc_line
+                        can_only_annotate_help: attribute
                             .can_only_annotate_help(target_friendly_name),
                     }
                     .into(),
                 );
             }
-        } else {
-            // For other attributes, the error is shown for every individual attribute.
-            for attribute in attributes {
-                if !can_annotate(attribute) {
-                    handler.emit_err(
-                        ConvertParseTreeError::InvalidAttributeTarget {
-                            span: attribute.name.span(),
-                            attribute: attribute.name.clone(),
-                            target_friendly_name,
-                            can_only_annotate_help: attribute
-                                .can_only_annotate_help(target_friendly_name),
-                        }
-                        .into(),
-                    );
-                }
-            }
         }
     }
 
@@ -376,25 +376,24 @@ pub(crate) fn attr_decls_to_attributes(
 
     // Check fixture-based testing requirements: #[case] or #[fuzz] require #[test]
     let has_test = attributes.of_kind(AttributeKind::Test).any(|_| true);
-    let has_case = attributes.of_kind(AttributeKind::Case).any(|_| true);
-    let has_fuzz = attributes.of_kind(AttributeKind::Fuzz).any(|_| true);
+    let has_parameterization = attributes.of_kind(AttributeKind::Case).any(|_| true) 
+        || attributes.of_kind(AttributeKind::Fuzz).any(|_| true);
+    
+    if !has_parameterization || has_test {
+        return (handler, attributes);
+    }
 
-    if (has_case || has_fuzz) && !has_test {
-        let parameterization_attr = if has_case {
-            attributes.of_kind(AttributeKind::Case).next()
-        } else {
-            attributes.of_kind(AttributeKind::Fuzz).next()
-        };
+    let first_param_attr = attributes.of_kind(AttributeKind::Case).next()
+        .or_else(|| attributes.of_kind(AttributeKind::Fuzz).next());
 
-        if let Some(attr) = parameterization_attr {
-            handler.emit_err(
-                ConvertParseTreeError::ParameterizedTestRequiresTestAttribute {
-                    span: attr.span.clone(),
-                    attribute: attr.name.clone(),
-                }
-                .into(),
-            );
-        }
+    if let Some(attr) = first_param_attr {
+        handler.emit_err(
+            ConvertParseTreeError::ParameterizedTestRequiresTestAttribute {
+                span: attr.span.clone(),
+                attribute: attr.name.clone(),
+            }
+            .into(),
+        );
     }
 
     (handler, attributes)

sway-core/src/transform/attribute.rs

@@ -618,23 +618,7 @@ impl Attribute {
             Allow => !matches!(item_kind, ItemKind::Submodule(_)),
             Cfg => !matches!(item_kind, ItemKind::Submodule(_)),
             // TODO: Adapt once https://github.com/FuelLabs/sway/issues/6942 is implemented.
-            Deprecated => match item_kind {
-                ItemKind::Submodule(_) => false,
-                ItemKind::Use(_) => false,
-                ItemKind::Struct(_) => true,
-                ItemKind::Enum(_) => true,
-                ItemKind::Fn(_) => true,
-                ItemKind::Trait(_) => false,
-                ItemKind::Impl(_) => false,
-                ItemKind::Abi(_) => false,
-                ItemKind::Const(_) => true,
-                ItemKind::Storage(_) => false,
-                // TODO: Currently, only single configurables can be deprecated.
-                //       Change to true once https://github.com/FuelLabs/sway/issues/6942 is implemented.
-                ItemKind::Configurable(_) => false,
-                ItemKind::TypeAlias(_) => false,
-                ItemKind::Error(_, _) => true,
-            },
+            Deprecated => Self::can_deprecate_item_kind(item_kind),
             Fallback => matches!(item_kind, ItemKind::Fn(_)),
             ErrorType => matches!(item_kind, ItemKind::Enum(_)),
             Error => false,
@@ -644,6 +628,27 @@ impl Attribute {
         }
     }
 
+    fn can_deprecate_item_kind(item_kind: &ItemKind) -> bool {
+        matches!(item_kind, 
+            ItemKind::Struct(_) | 
+            ItemKind::Enum(_) | 
+            ItemKind::Fn(_) | 
+            ItemKind::Const(_) | 
+            ItemKind::Error(_, _)
+        )
+    }
+
+    fn storage_help_text(target_friendly_name: &str) -> Vec<&'static str> {
+        if target_friendly_name == "function signature" {
+            vec![
+                "\"storage\" attribute can only annotate functions that have an implementation.",
+                "Function signatures in ABI and trait declarations do not have implementations.",
+            ]
+        } else {
+            vec!["\"storage\" attribute can only annotate functions."]
+        }
+    }
+
     // TODO: Add `can_annotated_nested_item_kind`, once we properly support nested items.
     //       E.g., the `#[test]` attribute can annotate module functions (`ItemKind::Fn`),
     //       but will not be allowed on nested functions.
@@ -820,18 +825,7 @@ impl Attribute {
                     vec![]
                 },
             },
-            Storage => {
-                if target_friendly_name == "function signature" {
-                    vec![
-                        "\"storage\" attribute can only annotate functions that have an implementation.",
-                        "Function signatures in ABI and trait declarations do not have implementations.",
-                    ]
-                } else {
-                    vec![
-                        "\"storage\" attribute can only annotate functions.",
-                    ]
-                }
-            },
+            Storage => Self::storage_help_text(target_friendly_name),
             Inline => vec!["\"inline\" attribute can only annotate functions."],
             Test => vec!["\"test\" attribute can only annotate module functions."],
             Payable => vec![