[anodized] feat: try_call! macro (#158)

- Introduce the `try_call!` proc macro in `anodized::runtime`.
- Add a stand-alone example: `bin-search`.
- Add a fuzz test to `bin-search`, using `cargo-fuzz` and the new
`try_call!` macro.
- Extend the CI setup to include the new `bin-search` example.
- Set the minimum Rust version to 1.95.

Author: mkovaxx

.github/workflows/ci.yml

@@ -150,3 +150,37 @@ jobs:
 
       - name: Smoke test fuzz target (fmt_ws_invariant)
         run: cargo +nightly fuzz build
+
+  test-example-bin-search:
+    name: Lint and smoke-test the `bin-search` example
+    runs-on: ubuntu-latest
+    needs: fmt
+    defaults:
+      run:
+        working-directory: ./examples/bin-search
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust nightly toolchain
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: clippy rustfmt
+
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+
+      - name: Lint
+        run: cargo clippy --all-targets -- -D warnings
+
+      - name: Build
+        run: cargo build
+
+      - name: Lint fuzz targets
+        run: cargo clippy --manifest-path ./fuzz/Cargo.toml --all-targets --config 'build.rustflags=["--cfg","anodized_print", "--cfg","anodized_panic", "--cfg","anodized_split_func"]' -- -D warnings
+
+      - name: Install cargo-fuzz
+        run: cargo install cargo-fuzz
+
+      - name: Build fuzz targets
+        run: cargo +nightly fuzz build -Ztarget-applies-to-host -Zhost-config

Cargo.toml

@@ -8,11 +8,15 @@ members = [
     "crates/test-util",
     "fuzz",
 ]
+exclude = [
+    "examples/bin-search",
+]
 resolver = "2"
 
 [workspace.package]
 version = "0.5.1"
 edition = "2024"
+rust-version = "1.95"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/anodized-rs/anodized"
 description = "A common specification layer for Rust"

crates/anodized-core/Cargo.toml

@@ -4,6 +4,7 @@ description = "Core interoperability for the Anodized specification system"
 
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 readme = "README.md"
 repository.workspace = true
 categories.workspace = true

crates/anodized-core/src/instrument.rs

@@ -42,6 +42,16 @@ impl Mode {
         !matches!(self, Mode::ChangeNothing)
     }
 
+    pub fn does_split_func(&self) -> bool {
+        if let Self::InjectChecks(check_settings) = self
+            && let Some(panic_settings) = &check_settings.does_panic
+        {
+            panic_settings.split_func
+        } else {
+            false
+        }
+    }
+
     pub fn with_split_func(&self, value: bool) -> Self {
         match self {
             Mode::ChangeNothing => Mode::ChangeNothing,
@@ -136,10 +146,7 @@ Instead, you likely need to place a `#[spec]` attribute on an enclosing trait or
     }
 
     fn build_split_fn(is_impl: bool, sig: &mut Signature, body: &mut Block) -> Ident {
-        let mangled_ident = Ident::new(
-            &format!("__anodized_fn_split_{}", sig.ident),
-            sig.ident.span(),
-        );
+        let mangled_ident = fns::make_split_fn_ident(&sig.ident);
 
         Self::build_wrapper_fn_signature(sig);
 

crates/anodized-core/src/instrument/fns.rs

@@ -378,3 +378,31 @@ impl CheckSettings {
         }
     }
 }
+
+pub(crate) fn make_split_fn_ident(ident: &Ident) -> Ident {
+    Ident::new(&format!("__anodized_fn_split_{ident}"), ident.span())
+}
+
+pub fn make_try_call(mut expr: Expr) -> Result<Expr> {
+    match &mut expr {
+        Expr::Call(fn_call) => {
+            if let Expr::Path(path) = fn_call.func.as_mut()
+                && (path.qself.is_some() || path.path.segments.len() > 1)
+            {
+                let last_segment = path.path.segments.last_mut().expect("last segment");
+                last_segment.ident = make_split_fn_ident(&last_segment.ident);
+                return Ok(expr);
+            }
+        }
+        Expr::MethodCall(method_call) => {
+            method_call.method = make_split_fn_ident(&method_call.method);
+            return Ok(expr);
+        }
+        _ => {}
+    }
+
+    Err(syn::Error::new_spanned(
+        expr,
+        "must be a method call or a qualified function call",
+    ))
+}

crates/anodized-core/src/instrument/fns_tests.rs

@@ -1015,3 +1015,85 @@ fn captures() {
         .unwrap();
     assert_tokens_eq(&observed, &expected);
 }
+
+#[test]
+fn try_call_free_fn() {
+    let input: Expr = parse_quote! {
+        module::FUNC(arg_1, arg_2)
+    };
+
+    let expected: Expr = parse_quote! {
+        module::__anodized_fn_split_FUNC(arg_1, arg_2)
+    };
+
+    let observed = make_try_call(input).expect("tryify");
+    assert_eq!(expected, observed);
+}
+
+#[test]
+fn try_call_method() {
+    let input: Expr = parse_quote! {
+        receiver.METHOD(arg_1, arg_2)
+    };
+
+    let expected: Expr = parse_quote! {
+        receiver.__anodized_fn_split_METHOD(arg_1, arg_2)
+    };
+
+    let observed = make_try_call(input).expect("tryify");
+    assert_eq!(expected, observed);
+}
+
+#[test]
+fn try_call_associated_fn() {
+    let input: Expr = parse_quote! {
+        Type::FUNC(arg_1, arg_2)
+    };
+
+    let expected: Expr = parse_quote! {
+        Type::__anodized_fn_split_FUNC(arg_1, arg_2)
+    };
+
+    let observed = make_try_call(input).expect("tryify");
+    assert_eq!(expected, observed);
+}
+
+#[test]
+fn try_call_turbofish_associated_fn() {
+    let input: Expr = parse_quote! {
+        <Type>::FUNC(arg_1, arg_2)
+    };
+
+    let expected: Expr = parse_quote! {
+        <Type>::__anodized_fn_split_FUNC(arg_1, arg_2)
+    };
+
+    let observed = make_try_call(input).expect("tryify");
+    assert_eq!(expected, observed);
+}
+
+#[test]
+fn try_call_trait_fn() {
+    let input: Expr = parse_quote! {
+        <Type as Trait>::FUNC(arg_1, arg_2)
+    };
+
+    let expected: Expr = parse_quote! {
+        <Type as Trait>::__anodized_fn_split_FUNC(arg_1, arg_2)
+    };
+
+    let observed = make_try_call(input).expect("tryify");
+    assert_eq!(expected, observed);
+}
+
+#[test]
+fn try_call_invalid() {
+    let input = parse_quote! {
+        free_fn(value)
+    };
+    let error = make_try_call(input).expect_err("invalid input");
+    assert_eq!(
+        error.to_string(),
+        "must be a method call or a qualified function call",
+    );
+}

crates/anodized-fmt/Cargo.toml

@@ -4,6 +4,7 @@ description = "Formatter for #[spec] annotations in Anodized"
 
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 readme = "README.md"
 repository.workspace = true
 categories.workspace = true

crates/anodized-logic/Cargo.toml

@@ -4,6 +4,7 @@ description = "Helps Anodized embed non-trivial elements of logic into Rust code
 
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 readme = "README.md"
 repository.workspace = true
 categories.workspace = true

crates/anodized-macros/Cargo.toml

@@ -4,6 +4,7 @@ description = "Proc macros used by the Anodized specification system"
 
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 readme = "README.md"
 repository.workspace = true
 categories.workspace = true

crates/anodized-macros/src/lib.rs

@@ -1,11 +1,13 @@
 #![doc = include_str!("../README.md")]
 
 use proc_macro::TokenStream;
-use syn::{Item, TraitItemFn, parse_macro_input};
+use proc_macro2::Span;
+use quote::ToTokens;
+use syn::{Expr, Item, TraitItemFn, parse_macro_input};
 
 use anodized_core::{
     DataSpec, Spec,
-    instrument::{CheckSettings, Mode, PanicSettings, make_item_error},
+    instrument::{CheckSettings, Mode, PanicSettings, fns::make_try_call, make_item_error},
 };
 
 const CONFIG: Mode = if cfg!(anodized_discard_specs) {
@@ -87,3 +89,38 @@ pub fn spec(args: TokenStream, input: TokenStream) -> TokenStream {
         Err(e) => e.to_compile_error().into(),
     }
 }
+
+/// Try to call a function with a `spec` and defer acting on pre/postcondition failures.
+///
+/// Returns `Result<T, (bool, String)>` where `T` is the original return type:
+///     - `Ok(output)` if pre- and postconditions passed.
+///     - `Err((false, errors))` if preconditions failed.
+///     - `Err((true, errors))` if postconditions failed.
+///
+/// The macro must wrap a call expression, targeting one of the following cases:
+/// - a free function with a qualified name:
+///     - `qualified::free_fn(...)`
+/// - a method:
+///     - `receiver.method(...)`
+/// - a function qualified by a type or trait:
+///     - `Type::associated_fn(...)`
+///     - `<Type>::associated_fn(...)`
+///     - `<Type as Trait>::trait_fn(...)`
+#[proc_macro]
+pub fn try_call(args: TokenStream) -> TokenStream {
+    if !CONFIG.does_split_func() {
+        return syn::Error::new(
+            Span::call_site(),
+            "`try_call` needs the `anodized_split_func` build `cfg` to be enabled",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    let expr = parse_macro_input!(args as Expr);
+
+    match make_try_call(expr) {
+        Ok(call) => call.into_token_stream().into(),
+        Err(error) => error.to_compile_error().into(),
+    }
+}