Merge branch 'master' into 'master'

Fixed {} in assert message, self in post, and unbound patterns

See merge request karroffel/contracts!7

Author: karroffel

.gitlab-ci.yml

@@ -18,10 +18,17 @@ test-stable:
     - cargo test --all
 
 
-
 test-nightly:
   stage: test
   image: rustlang/rust:nightly
   script:
     - cargo test --all
   allow_failure: true
+
+clippy-tests-stable:
+  stage: test
+  image: rust:latest
+  before_script:
+    - rustup component add clippy
+  script:
+    - cargo clippy --tests

src/implementation/codegen.rs

@@ -188,7 +188,7 @@ pub(crate) fn generate(
             result.extend(
                 quote::quote_spanned! { span=>
                     if !(#exec_expr) {
-                        log::error!(#format_args);
+                        log::error!("{}", #format_args);
                     }
                 }
                 .into_iter(),
@@ -198,7 +198,7 @@ pub(crate) fn generate(
         if let Some(assert_macro) = get_assert_macro(ctype, mode, span) {
             result.extend(
                 quote::quote_spanned! { span=>
-                    #assert_macro!(#exec_expr, #format_args);
+                    #assert_macro!(#exec_expr, "{}", #format_args);
                 }
                 .into_iter(),
             );
@@ -460,7 +460,21 @@ fn create_body_closure(func: &syn::ItemFn) -> TokenStream {
         }
 
         closure_args.push(receiver);
-        arg_names.push(syn::Ident::new("self", Span::call_site()));
+
+        match &func.sig.inputs[0] {
+            syn::FnArg::Receiver(receiver) => {
+                arg_names
+                    .push(syn::Ident::new("self", receiver.self_token.span()));
+            }
+            syn::FnArg::Typed(pat) => {
+                if let syn::Pat::Ident(ident) = &*pat.pat {
+                    arg_names.push(ident.ident.clone());
+                } else {
+                    // Non-trivial receiver pattern => do not capture
+                    closure_args.pop();
+                }
+            }
+        };
 
         // Replace any references to `self` in the function body with references to `this`.
         syn::visit_mut::visit_block_mut(
@@ -482,8 +496,16 @@ fn create_body_closure(func: &syn::ItemFn) -> TokenStream {
             syn::FnArg::Typed(syn::PatType { pat, ty, .. }) => {
                 if !ty_contains_impl_trait(ty) {
                     if let syn::Pat::Ident(ident) = &**pat {
-                        arg_names.push(ident.ident.clone());
-                        closure_args.push(arg.clone());
+                        let ident_str = ident.ident.to_string();
+
+                        // Any function argument identifier starting with '_' signals
+                        // that the binding will not be used.
+                        if !ident_str.starts_with('_')
+                            || ident_str.starts_with("__")
+                        {
+                            arg_names.push(ident.ident.clone());
+                            closure_args.push(arg.clone());
+                        }
                     }
                 }
             }

tests/functions.rs

@@ -117,7 +117,8 @@ fn test_impl_trait_return() {
     // qualified types works properly.
 
     #[requires(x >= 10)]
-    #[ensures(ret.clone() == ret)]
+    #[ensures(Clone::clone(&ret) == ret)]
+    #[allow(unused_variables)]
     fn impl_test(x: isize) -> impl Clone + PartialEq + std::fmt::Debug {
         "it worked"
     }
@@ -132,16 +133,37 @@ fn test_impl_trait_return() {
 
 #[test]
 fn test_impl_trait_arg() {
-    #[requires(x.clone() == x)]
-    #[ensures(ret.clone() == ret)]
+    #[requires(Clone::clone(&x) == x)]
+    #[ensures(Clone::clone(&ret) == ret)]
     fn impl_test(x: impl Clone + PartialEq + std::fmt::Debug) -> &'static str {
         "it worked"
     }
 
     let x = impl_test(200);
-    let y = x.clone();
+    let y = Clone::clone(&x);
     assert_eq!(
         format!("{:?} and {:?}", x, y),
         r#""it worked" and "it worked""#
     );
 }
+
+#[test]
+#[deny(clippy::used_underscore_binding)]
+fn test_unbound_parameters_clippy() {
+    #[requires(__y == 3)]
+    #[ensures(ret)]
+    fn param_test(_x: i32, __y: i32) -> bool {
+        true
+    }
+}
+
+#[test]
+#[deny(non_fmt_panic)]
+fn test_braced_condition_expression_clippy() {
+    #[requires(if __y == 3 {
+        __y != 0
+    } else {
+        false
+    })]
+    fn param_test(_x: i32, __y: i32) {}
+}

tests/implication.rs

@@ -53,6 +53,7 @@ fn test_requires_implication() {
 #[should_panic(expected = "Post")]
 fn test_failing_implication() {
     #[ensures(t -> ret)]
+    #[allow(unused_variables)]
     fn only_true(t: bool) -> bool {
         false // oops
     }

tests/methods.rs

@@ -101,3 +101,37 @@ fn impl_invariant() {
     adder.prev_even();
     adder.prev_even();
 }
+
+#[test]
+fn test_self_macro_hygiene() {
+    struct S {
+        value: i32,
+    }
+
+    // Use a macro to generate the function impl
+    // This requires strict hygiene of the `self` receiver
+    macro_rules! __impl {
+        (
+            $(#[$metas:meta])*
+            fn $function:ident(&mut $this:ident, $value:ident: $ty:ty)
+            $body:block
+        ) => {
+            $(#[$metas])*
+            fn $function(&mut $this, $value: $ty)
+            $body
+        };
+    }
+
+    impl S {
+        __impl! {
+            #[ensures(self.value == old(value))]
+            fn set_value(&mut self, value: i32) {
+                self.value = value;
+            }
+        }
+    }
+
+    let mut s = S { value: 24 };
+    s.set_value(42);
+    assert_eq!(s.value, 42);
+}