Refactor function names generated by plugin (#3671)

<!-- Reference any GitHub issues resolved by this PR -->

Towards #1431

**Stack**:
- #3697
- #3669
- #3671 ⬅
- #3670

## Introduced changes

This change makes the name of the test function remain the same.
Previously, we modified its name by adding `_return_wrapper` and
`_actual_body` suffixes. However, while implementing `#[test_case]`, it
turned out its tricky to determine the name of the function to be
called.

## Checklist

<!-- Make sure all of these are complete -->

- [ ] Linked relevant issue
- [ ] Updated relevant documentation
- [ ] Added relevant tests
- [x] Performed self-review of the code
- [ ] Added changes to `CHANGELOG.md`

Author: franciszekjob

crates/forge-runner/src/package_tests/with_config_resolved.rs

@@ -1,5 +1,5 @@
 use super::{TestCase, TestTarget};
-use crate::expected_result::ExpectedTestResult;
+use crate::{expected_result::ExpectedTestResult, package_tests::TestDetails};
 use anyhow::Result;
 use cairo_vm::types::program::Program;
 use cheatnet::runtime_extensions::forge_config_extension::config::{
@@ -13,7 +13,22 @@ pub type TestTargetWithResolvedConfig = TestTarget<TestCaseResolvedConfig>;
 
 pub type TestCaseWithResolvedConfig = TestCase<TestCaseResolvedConfig>;
 
+fn sanitize_test_case_name(name: &str) -> String {
+    // Test names generated by `#[test]` and `#[fuzzer]` macros contain internal suffixes
+    name.replace("__snforge_internal_test_generated", "")
+        .replace("__snforge_internal_fuzzer_generated", "")
+}
+
 impl TestCaseWithResolvedConfig {
+    #[must_use]
+    pub fn new(name: &str, test_details: TestDetails, config: TestCaseResolvedConfig) -> Self {
+        Self {
+            name: sanitize_test_case_name(name),
+            test_details,
+            config,
+        }
+    }
+
     pub fn try_into_program(
         &self,
         casm_program: &AssembledProgramWithDebugInfo,

crates/forge/src/run_tests/resolve_config.rs

@@ -24,24 +24,25 @@ pub async fn resolve_config(
     let env_ignore_fork_tests = env_ignore_fork_tests();
 
     for case in test_target.test_cases {
-        test_cases.push(TestCaseWithResolvedConfig {
-            name: case.name,
-            test_details: case.test_details,
-            config: TestCaseResolvedConfig {
-                available_gas: case.config.available_gas,
-                ignored: case.config.ignored
-                    || (env_ignore_fork_tests && case.config.fork_config.is_some()),
-                expected_result: case.config.expected_result,
-                fork_config: resolve_fork_config(
-                    case.config.fork_config,
-                    block_number_map,
-                    fork_targets,
-                )
-                .await?,
-                fuzzer_config: case.config.fuzzer_config,
-                disable_predeployed_contracts: case.config.disable_predeployed_contracts,
-            },
-        });
+        let config = TestCaseResolvedConfig {
+            available_gas: case.config.available_gas,
+            ignored: case.config.ignored
+                || (env_ignore_fork_tests && case.config.fork_config.is_some()),
+            expected_result: case.config.expected_result,
+            fork_config: resolve_fork_config(
+                case.config.fork_config,
+                block_number_map,
+                fork_targets,
+            )
+            .await?,
+            fuzzer_config: case.config.fuzzer_config,
+            disable_predeployed_contracts: case.config.disable_predeployed_contracts,
+        };
+        test_cases.push(TestCaseWithResolvedConfig::new(
+            &case.name,
+            case.test_details,
+            config,
+        ));
     }
 
     Ok(TestTargetWithResolvedConfig {

crates/snforge-scarb-plugin/src/attributes/fuzzer/wrapper.rs

@@ -67,8 +67,10 @@ fn fuzzer_wrapper_internal(
     let vis = func.visibility(db).as_syntax_node();
     let vis = SyntaxNodeWithDb::new(&vis, db);
 
-    let name = func.declaration(db).name(db).as_syntax_node();
-    let name = SyntaxNodeWithDb::new(&name, db);
+    let name = format_ident!(
+        "{}__snforge_internal_fuzzer_generated",
+        func.declaration(db).name(db).text(db)
+    );
 
     let signature = func.declaration(db).signature(db).as_syntax_node();
     let signature = SyntaxNodeWithDb::new(&signature, db);
@@ -104,8 +106,8 @@ fn fuzzer_wrapper_internal(
         }
     });
 
-    let actual_body_fn_name =
-        format_ident!("{}_actual_body", func.declaration(db).name(db).text(db));
+    let func_name = func.declaration(db).name(db).as_syntax_node();
+    let func_name = SyntaxNodeWithDb::new(&func_name, db);
 
     let (statements, if_content) = get_statements(db, func);
 
@@ -117,17 +119,17 @@ fn fuzzer_wrapper_internal(
                 if snforge_std::_internals::is_config_run() {
                     #if_content
 
-                    #actual_body_fn_name(#blank_values_for_config_run);
+                    #func_name(#blank_values_for_config_run);
 
                     return;
                 }
                 #fuzzer_assignments
-                #actual_body_fn_name(#arguments_list);
+                #func_name(#arguments_list);
             }
 
             #actual_body_fn_attrs
             #[#internal_config_attr]
-            fn #actual_body_fn_name #signature {
+            fn #func_name #signature {
                 #statements
             }
     ))

crates/snforge-scarb-plugin/src/attributes/test.rs

@@ -1,7 +1,6 @@
 use super::{AttributeInfo, ErrorExt, internal_config_statement::InternalConfigStatementCollector};
 use crate::asserts::assert_is_used_once;
-use crate::attributes::fuzzer::wrapper::FuzzerWrapperCollector;
-use crate::attributes::fuzzer::{FuzzerCollector, FuzzerConfigCollector};
+use crate::common::has_fuzzer_attribute;
 use crate::external_inputs::ExternalInput;
 use crate::utils::create_single_token;
 use crate::{
@@ -13,7 +12,6 @@ use cairo_lang_macro::{Diagnostic, Diagnostics, ProcMacroResult, TokenStream, qu
 use cairo_lang_parser::utils::SimpleParserDatabase;
 use cairo_lang_syntax::node::with_db::SyntaxNodeWithDb;
 use cairo_lang_syntax::node::{Terminal, TypedSyntaxNode, ast::FunctionWithBody};
-use std::ops::Not;
 
 pub struct TestCollector;
 
@@ -55,8 +53,15 @@ fn test_internal(
         None => true,
     };
 
-    let name = func.declaration(db).name(db).as_syntax_node();
-    let name = SyntaxNodeWithDb::new(&name, db);
+    let has_fuzzer = has_fuzzer_attribute(db, func);
+
+    // If there is `#[fuzzer]` attribute, called function is suffixed with `__snforge_internal_fuzzer_generated`
+    // `#[__fuzzer_wrapper]` is responsible for adding this suffix.
+    let called_func_ident = if has_fuzzer {
+        format_ident!("{name}__snforge_internal_fuzzer_generated")
+    } else {
+        format_ident!("{}", name)
+    };
 
     let signature = func.declaration(db).signature(db).as_syntax_node();
     let signature = SyntaxNodeWithDb::new(&signature, db);
@@ -68,35 +73,32 @@ fn test_internal(
     let attributes = func.attributes(db).as_syntax_node();
     let attributes = SyntaxNodeWithDb::new(&attributes, db);
 
-    let name_return_wrapper =
-        format_ident!("{}_return_wrapper", func.declaration(db).name(db).text(db));
-
-    let mut return_wrapper = TokenStream::new(vec![name_return_wrapper.clone()]);
-    return_wrapper.extend(signature);
+    let test_func_ident = format_ident!("{}__snforge_internal_test_generated", name);
+    let func_ident = format_ident!("{}", name);
 
     let out_of_gas = create_single_token("'Out of gas'");
 
     if should_run_test {
         Ok(quote!(
             #[implicit_precedence(core::pedersen::Pedersen, core::RangeCheck, core::integer::Bitwise, core::ec::EcOp, core::poseidon::Poseidon, core::SegmentArena, core::circuit::RangeCheck96, core::circuit::AddMod, core::circuit::MulMod, core::gas::GasBuiltin, System)]
             #[snforge_internal_test_executable]
-            fn #name(mut _data: Span<felt252>) -> Span::<felt252> {
+            fn #test_func_ident(mut _data: Span<felt252>) -> Span::<felt252> {
                 core::internal::require_implicit::<System>();
                 core::internal::revoke_ap_tracking();
                 core::option::OptionTraitImpl::expect(core::gas::withdraw_gas(), #out_of_gas);
 
                 core::option::OptionTraitImpl::expect(
                     core::gas::withdraw_gas_all(core::gas::get_builtin_costs()), #out_of_gas
                 );
-                #name_return_wrapper();
+                #called_func_ident();
 
                 let mut arr = ArrayTrait::new();
                 core::array::ArrayTrait::span(@arr)
             }
 
             #attributes
             #[#internal_config]
-            fn #return_wrapper
+            fn #func_ident #signature
             #body
         ))
     } else {
@@ -111,7 +113,7 @@ fn ensure_parameters_only_with_fuzzer_attribute(
     db: &SimpleParserDatabase,
     func: &FunctionWithBody,
 ) -> Result<(), Diagnostic> {
-    if has_parameters(db, func) && no_fuzzer_attribute(db, func) {
+    if has_parameters(db, func) && !has_fuzzer_attribute(db, func) {
         Err(TestCollector::error(
             "function with parameters must have #[fuzzer] attribute",
         ))?;
@@ -128,24 +130,3 @@ fn has_parameters(db: &SimpleParserDatabase, func: &FunctionWithBody) -> bool {
         .len()
         != 0
 }
-
-fn no_fuzzer_attribute(db: &SimpleParserDatabase, func: &FunctionWithBody) -> bool {
-    const FUZZER_ATTRIBUTES: [&str; 3] = [
-        FuzzerCollector::ATTR_NAME,
-        FuzzerWrapperCollector::ATTR_NAME,
-        FuzzerConfigCollector::ATTR_NAME,
-    ];
-
-    func.attributes(db)
-        .elements(db)
-        .any(|attr| {
-            FUZZER_ATTRIBUTES.contains(
-                &attr
-                    .attr(db)
-                    .as_syntax_node()
-                    .get_text_without_trivia(db)
-                    .as_str(),
-            )
-        })
-        .not()
-}

crates/snforge-scarb-plugin/src/common.rs

@@ -1,11 +1,14 @@
 use crate::{
     args::Arguments,
-    attributes::AttributeInfo,
+    attributes::{
+        AttributeInfo,
+        fuzzer::{FuzzerCollector, FuzzerConfigCollector, wrapper::FuzzerWrapperCollector},
+    },
     parse::{parse, parse_args},
 };
 use cairo_lang_macro::{Diagnostic, Diagnostics, ProcMacroResult, TokenStream};
 use cairo_lang_parser::utils::SimpleParserDatabase;
-use cairo_lang_syntax::node::ast::FunctionWithBody;
+use cairo_lang_syntax::node::{TypedSyntaxNode, ast::FunctionWithBody};
 use cairo_lang_utils::Upcast;
 
 #[expect(clippy::needless_pass_by_value)]
@@ -58,3 +61,28 @@ where
 
     handler(db, &func, args_db, args, warns)
 }
+
+fn has_any_attribute(
+    db: &SimpleParserDatabase,
+    func: &FunctionWithBody,
+    attr_names: &[&str],
+) -> bool {
+    func.attributes(db).elements(db).any(|attr| {
+        attr_names.contains(
+            &attr
+                .attr(db)
+                .as_syntax_node()
+                .get_text_without_trivia(db)
+                .as_str(),
+        )
+    })
+}
+
+pub fn has_fuzzer_attribute(db: &SimpleParserDatabase, func: &FunctionWithBody) -> bool {
+    const FUZZER_ATTRIBUTES: [&str; 3] = [
+        FuzzerCollector::ATTR_NAME,
+        FuzzerWrapperCollector::ATTR_NAME,
+        FuzzerConfigCollector::ATTR_NAME,
+    ];
+    has_any_attribute(db, func, &FUZZER_ATTRIBUTES)
+}