Fix clippy and fmt issues

benches/themis/benches/secure_message_encrypt_decrypt_ecdsa.rs

@@ -106,7 +106,7 @@ pub fn decryption(c: &mut Criterion) {
             |b, &size| {
                 let message = vec![0; size];
                 let encrypted = SecureMessage::new(key_pair.clone())
-                    .encrypt(&message)
+                    .encrypt(message)
                     .expect("failed encryption");
 
                 let mut decrypted = vec![0; size];

benches/themis/benches/secure_message_encrypt_decrypt_rsa.rs

@@ -106,7 +106,7 @@ pub fn decryption(c: &mut Criterion) {
             |b, &size| {
                 let message = vec![0; size];
                 let encrypted = SecureMessage::new(key_pair.clone())
-                    .encrypt(&message)
+                    .encrypt(message)
                     .expect("failed encryption");
 
                 let mut decrypted = vec![0; size];

benches/themis/benches/secure_message_sign_verify_ecdsa.rs

@@ -102,7 +102,7 @@ pub fn verification(c: &mut Criterion) {
             |b, &size| {
                 let message = vec![0; size];
                 let signature = SecureSign::new(private.clone())
-                    .sign(&message)
+                    .sign(message)
                     .expect("failed signing");
 
                 let mut received_message = vec![0; size];

benches/themis/benches/secure_message_sign_verify_rsa.rs

@@ -102,7 +102,7 @@ pub fn verification(c: &mut Criterion) {
             |b, &size| {
                 let message = vec![0; size];
                 let signature = SecureSign::new(private.clone())
-                    .sign(&message)
+                    .sign(message)
                     .expect("failed signing");
 
                 let mut received_message = vec![0; size];

docs/examples/rust/secure_cell.rs

@@ -33,7 +33,7 @@ fn main() -> themis::Result<()> {
 
         println!("Encoded:   {}", base64::encode(&message));
 
-        let encrypted_message = scell_mk.encrypt(&message)?;
+        let encrypted_message = scell_mk.encrypt(message)?;
         println!("Encrypted: {}", base64::encode(&encrypted_message));
 
         let decrypted_message = scell_mk.decrypt(&encrypted_message)?;
@@ -44,11 +44,11 @@ fn main() -> themis::Result<()> {
 
     println!("## Passphrase API");
     {
-        let scell_pw = SecureCell::with_passphrase(&passphrase)?.seal();
+        let scell_pw = SecureCell::with_passphrase(passphrase)?.seal();
 
         println!("Encoded:   {}", base64::encode(&message));
 
-        let encrypted_message = scell_pw.encrypt(&message)?;
+        let encrypted_message = scell_pw.encrypt(message)?;
         println!("Encrypted: {}", base64::encode(&encrypted_message));
 
         let decrypted_message = scell_pw.decrypt(&encrypted_message)?;
@@ -64,7 +64,7 @@ fn main() -> themis::Result<()> {
 
         println!("Encoded:    {}", base64::encode(&message));
 
-        let (encrypted_message, auth_token) = scell_tp.encrypt(&message)?;
+        let (encrypted_message, auth_token) = scell_tp.encrypt(message)?;
         println!("Encrypted:  {}", base64::encode(&encrypted_message));
         println!("Auth token: {}", base64::encode(&auth_token));
 
@@ -81,10 +81,10 @@ fn main() -> themis::Result<()> {
 
         println!("Encoded:   {}", base64::encode(&message));
 
-        let encrypted_message = scell_ci.encrypt_with_context(&message, &context)?;
+        let encrypted_message = scell_ci.encrypt_with_context(message, context)?;
         println!("Encrypted: {}", base64::encode(&encrypted_message));
 
-        let decrypted_message = scell_ci.decrypt_with_context(&encrypted_message, &context)?;
+        let decrypted_message = scell_ci.decrypt_with_context(&encrypted_message, context)?;
         println!("Decrypted: {}", as_str(&decrypted_message));
         assert_eq!(decrypted_message, message);
     }

docs/examples/rust/secure_message_client_encrypt.rs

@@ -51,7 +51,7 @@ fn main() {
     let key_pair = KeyPair::try_join(private_key, public_key).expect("matching keys");
 
     let socket = UdpSocket::bind("localhost:0").expect("client socket");
-    socket.connect(&remote_addr).expect("client connection");
+    socket.connect(remote_addr).expect("client connection");
 
     let receive_socket = socket;
     let relay_socket = receive_socket.try_clone().unwrap();

docs/examples/rust/secure_message_client_verify.rs

@@ -49,7 +49,7 @@ fn main() {
     let public_key = PublicKey::try_from_slice(public_key).expect("parse public key");
 
     let socket = UdpSocket::bind("localhost:0").expect("client socket");
-    socket.connect(&remote_addr).expect("client connection");
+    socket.connect(remote_addr).expect("client connection");
 
     let receive_socket = socket;
     let relay_socket = receive_socket.try_clone().unwrap();

docs/examples/rust/secure_message_server.rs

@@ -36,7 +36,7 @@ fn main() {
     let port = matches.value_of("port").unwrap_or("7573").parse().unwrap();
     let listen_addr = SocketAddr::new([0; 16].into(), port);
 
-    let socket = UdpSocket::bind(&listen_addr).expect("server listen");
+    let socket = UdpSocket::bind(listen_addr).expect("server listen");
     let mut peers = HashSet::new();
     let mut process_message = || -> io::Result<()> {
         let (message, sender) = recv_from(&socket)?;

docs/examples/rust/secure_session_echo_client.rs

@@ -64,9 +64,9 @@ fn main() {
 
     info!("connecting to {:?}", remote_addr);
 
-    let mut socket = TcpStream::connect(&remote_addr).expect("client connection");
+    let mut socket = TcpStream::connect(remote_addr).expect("client connection");
 
-    let mut session = SecureSession::new(&CLIENT_ID, &CLIENT_PRIVATE, ExpectServer)
+    let mut session = SecureSession::new(CLIENT_ID, &CLIENT_PRIVATE, ExpectServer)
         .expect("Secure Session client");
     let mut buffer = [0; MAX_MESSAGE_SIZE];
 
@@ -75,7 +75,7 @@ fn main() {
 
     loop {
         let reply = read_framed(&mut socket, &mut buffer).expect("receive reply");
-        let response = session.negotiate_reply(&reply).expect("negotiate");
+        let response = session.negotiate_reply(reply).expect("negotiate");
         if session.is_established() {
             break;
         }
@@ -95,7 +95,7 @@ fn main() {
         write_framed(&mut socket, &message).expect("write to socket");
 
         let reply = read_framed(&mut socket, &mut buffer).expect("read from socket");
-        let reply = session.unwrap(&reply).expect("unwrap incoming");
+        let reply = session.unwrap(reply).expect("unwrap incoming");
 
         io::stdout().write_all(&reply).expect("write to stdout");
     }

docs/examples/rust/secure_session_echo_server.rs

@@ -105,7 +105,7 @@ fn main() {
         .expect("valid port");
 
     let listen_addr = SocketAddr::new([0; 16].into(), port);
-    let listen_socket = TcpListener::bind(&listen_addr).expect("server listen");
+    let listen_socket = TcpListener::bind(listen_addr).expect("server listen");
 
     info!("listening on port {}", port);
 
@@ -123,7 +123,7 @@ fn main() {
             info!("{:?}: connected", client_address);
 
             let transport = SocketTransport::new(client);
-            let mut session = SecureSession::new(&SERVER_ID, &SERVER_PRIVATE, transport)
+            let mut session = SecureSession::new(SERVER_ID, &SERVER_PRIVATE, transport)
                 .expect("Secure Session server");
 
             while !session.is_established() {

src/wrappers/themis/rust/src/secure_cell.rs

@@ -358,7 +358,7 @@ impl SecureCellSeal {
     /// # }
     /// ```
     pub fn encrypt(&self, message: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.encrypt_with_context(message, &[])
+        self.encrypt_with_context(message, [])
     }
 
     /// Encrypts the provided message with associated context.
@@ -501,7 +501,7 @@ impl SecureCellSeal {
     /// # }
     /// ```
     pub fn decrypt(&self, message: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.decrypt_with_context(message, &[])
+        self.decrypt_with_context(message, [])
     }
 
     /// Decrypts the provided message with associated context.
@@ -689,7 +689,7 @@ impl SecureCellSealWithPassphrase {
     /// # }
     /// ```
     pub fn encrypt(&self, message: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.encrypt_with_context(message, &[])
+        self.encrypt_with_context(message, [])
     }
 
     /// Encrypts the provided message with associated context.
@@ -822,7 +822,7 @@ impl SecureCellSealWithPassphrase {
     /// # }
     /// ```
     pub fn decrypt(&self, message: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.decrypt_with_context(message, &[])
+        self.decrypt_with_context(message, [])
     }
 
     /// Decrypts the provided message with associated context.
@@ -1225,7 +1225,7 @@ impl SecureCellTokenProtect {
     /// # }
     /// ```
     pub fn encrypt(&self, message: impl AsRef<[u8]>) -> Result<(Vec<u8>, Vec<u8>)> {
-        self.encrypt_with_context(message, &[])
+        self.encrypt_with_context(message, [])
     }
 
     /// Encrypts the provided message with associated context.
@@ -1393,7 +1393,7 @@ impl SecureCellTokenProtect {
     /// # }
     /// ```
     pub fn decrypt(&self, message: impl AsRef<[u8]>, token: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.decrypt_with_context(message, token, &[])
+        self.decrypt_with_context(message, token, [])
     }
 
     /// Decrypts the provided message with associated context.

tests/rust/keys.rs

@@ -64,10 +64,10 @@ fn parse_generated_keys_back() {
 
 #[test]
 fn parse_invalid_buffers() {
-    let error = EcdsaPublicKey::try_from_slice(&[1, 2, 3]).expect_err("parse failure");
+    let error = EcdsaPublicKey::try_from_slice([1, 2, 3]).expect_err("parse failure");
     assert_eq!(error.kind(), ErrorKind::InvalidParameter);
 
-    let error = RsaPrivateKey::try_from_slice(&[]).expect_err("parse failure");
+    let error = RsaPrivateKey::try_from_slice([]).expect_err("parse failure");
     assert_eq!(error.kind(), ErrorKind::InvalidParameter);
 }
 
@@ -105,6 +105,6 @@ fn parse_generated_symmetric_keys_back() {
 
 #[test]
 fn parse_custom_symmetric_keys() {
-    assert!(SymmetricKey::try_from_slice(&[0]).is_ok());
-    assert!(SymmetricKey::try_from_slice(&[]).is_err());
+    assert!(SymmetricKey::try_from_slice([0]).is_ok());
+    assert!(SymmetricKey::try_from_slice([]).is_err());
 }