chore(tfhe): update toolchain to avoid SIMD breakage, fix lints

Makefile

@@ -158,6 +158,12 @@ clippy_core: install_rs_check_toolchain
 	RUSTFLAGS="$(RUSTFLAGS)" cargo "$(CARGO_RS_CHECK_TOOLCHAIN)" clippy \
 		--features=$(TARGET_ARCH_FEATURE),experimental \
 		-p $(TFHE_SPEC) -- --no-deps -D warnings
+	RUSTFLAGS="$(RUSTFLAGS)" cargo "$(CARGO_RS_CHECK_TOOLCHAIN)" clippy \
+		--features=$(TARGET_ARCH_FEATURE),nightly-avx512 \
+		-p $(TFHE_SPEC) -- --no-deps -D warnings
+	RUSTFLAGS="$(RUSTFLAGS)" cargo "$(CARGO_RS_CHECK_TOOLCHAIN)" clippy \
+		--features=$(TARGET_ARCH_FEATURE),experimental,nightly-avx512 \
+		-p $(TFHE_SPEC) -- --no-deps -D warnings
 
 .PHONY: clippy_boolean # Run clippy lints enabling the boolean features
 clippy_boolean: install_rs_check_toolchain

tasks/src/format_latex_doc.rs

@@ -196,7 +196,7 @@ fn find_contiguous_doc_test<'a>(
 
 fn find_contiguous_part_in_doc_test_or_comment(
     part_is_code_block: bool,
-    full_doc_comment_content: &Vec<CommentContent>,
+    full_doc_comment_content: &[CommentContent],
     part_start_idx: usize,
 ) -> (usize, usize) {
     let mut next_line_idx = part_start_idx + 1;
@@ -348,7 +348,7 @@ fn process_doc_lines_until_impossible<'a>(
 }
 
 fn process_non_doc_lines_until_impossible(
-    lines: &Vec<&str>,
+    lines: &[&str],
     rewritten_content: &mut String,
     mut line_idx: usize,
 ) -> usize {

tfhe/Cargo.toml

@@ -57,8 +57,8 @@ lazy_static = { version = "1.4.0", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 rayon = { version = "1.5.0" }
 bincode = { version = "1.3.3", optional = true }
-concrete-fft = { version = "0.3.0", features = ["serde", "fft128"] }
-pulp = "0.13"
+concrete-fft = { version = "0.4.0", features = ["serde", "fft128"] }
+pulp = "0.18.8"
 aligned-vec = { version = "0.5", features = ["serde"] }
 dyn-stack = { version = "0.9" }
 paste = { version = "1.0.7", optional = true }
@@ -79,7 +79,7 @@ js-sys = { version = "0.3", optional = true }
 console_error_panic_hook = { version = "0.1.7", optional = true }
 serde-wasm-bindgen = { version = "0.6.0", optional = true }
 getrandom = { version = "0.2.8", optional = true }
-bytemuck = "=1.14.1"
+bytemuck = "1.14.3"
 
 [features]
 forward_compatibility = [

tfhe/benches/shortint/bench.rs

@@ -393,7 +393,7 @@ fn _bench_wopbs_param_message_8_norm2_5(c: &mut Criterion) {
     let mut bench_group = c.benchmark_group("programmable_bootstrap");
 
     let param = WOPBS_PARAM_MESSAGE_4_NORM2_6_KS_PBS;
-    let param_set: ShortintParameterSet = param.try_into().unwrap();
+    let param_set: ShortintParameterSet = param.into();
     let pbs_params = param_set.pbs_parameters().unwrap();
 
     let keys = KEY_CACHE_WOPBS.get_from_param((pbs_params, param));

tfhe/c_api_tests/test_forward_compatibility.c

@@ -21,6 +21,8 @@ int uint8_format_update(const ClientKey *client_key, const ServerKey *server_key
 
   uint8_t lhs_clear = 123;
 
+  assert(1 == 0);
+
   ok = client_key_serialize(client_key, &cks_buffer);
   assert(ok == 0);
 

tfhe/examples/regex_engine/engine.rs

@@ -19,7 +19,7 @@ pub fn has_match(
 
     let res = if branches.len() <= 1 {
         branches
-            .get(0)
+            .first()
             .map_or(exec.ct_false(), |branch| branch(&mut exec))
             .0
     } else {

tfhe/src/core_crypto/fft_impl/fft128_u128/crypto/tests.rs

@@ -1,6 +1,7 @@
 use dyn_stack::{GlobalPodBuffer, PodStack, ReborrowMut};
 
 use super::super::super::{fft128, fft128_u128};
+#[allow(unused_imports)]
 use super::super::math::fft::{Fft128, Fft128View};
 use crate::core_crypto::prelude::*;
 use aligned_vec::CACHELINE_ALIGN;

tfhe/src/core_crypto/fft_impl/fft128_u128/math/fft/mod.rs

@@ -1,13 +1,14 @@
 use crate::core_crypto::commons::utils::izip;
+#[allow(unused_imports)]
 pub use crate::core_crypto::fft_impl::fft128::math::fft::{Fft128, Fft128View};
 use concrete_fft::fft128::f128;
 use dyn_stack::PodStack;
 
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-use pulp::x86::{f64x4, u64x4, V3};
+use pulp::{f64x4, u64x4, x86::V3};
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 #[cfg(feature = "nightly-avx512")]
-use pulp::x86::{f64x8, u64x8, V4};
+use pulp::{f64x8, u64x8, x86::V4};
 
 #[inline(always)]
 pub fn zeroing_shl(x: u64, shift: u64) -> u64 {

tfhe/src/core_crypto/fft_impl/fft64/crypto/ggsw.rs

@@ -671,7 +671,7 @@ pub(crate) fn update_with_fmadd(
                         let lhs = S::c64s_as_simd(ggsw_poly).0;
 
                         for (out, &lhs, &rhs) in izip!(out, lhs, rhs) {
-                            *out = simd.c64s_mul_adde(lhs, rhs, *out);
+                            *out = simd.c64s_mul_add_e(lhs, rhs, *out);
                         }
                     }
                 }
@@ -737,7 +737,7 @@ pub(crate) fn update_with_fmadd_factor(
                 } else {
                     for (out, &lhs, &rhs) in izip!(out, lhs, rhs) {
                         // NOTE: see above
-                        *out = simd.c64s_mul_adde(factor, simd.c64s_mul(lhs, rhs), *out);
+                        *out = simd.c64s_mul_add_e(factor, simd.c64s_mul(lhs, rhs), *out);
                     }
                 }
             }

tfhe/src/high_level_api/integers/keys.rs

@@ -204,9 +204,7 @@ impl IntegerCompactPublicKey {
     where
         T: crate::integer::block_decomposition::DecomposableInto<u64>,
     {
-        let Some(key) = self.key.as_ref() else {
-            return None;
-        };
+        let key = self.key.as_ref()?;
         let ct = key.encrypt_slice_radix_compact(values, num_blocks);
         Some(ct)
     }

tfhe/src/high_level_api/integers/parameters.rs

@@ -2,6 +2,7 @@ use crate::high_level_api::internal_traits::ParameterType;
 
 /// Meant to be implemented on the inner server key
 /// eg the crate::integer::ServerKey
+#[allow(dead_code)]
 pub trait EvaluationIntegerKey<ClientKey> {
     fn new(client_key: &ClientKey) -> Self;
 

tfhe/src/high_level_api/integers/types/mod.rs

@@ -1,3 +1,4 @@
+#[allow(unused_imports)]
 pub use base::GenericInteger;
 
 expand_pub_use_fhe_type!(

tfhe/src/high_level_api/internal_traits.rs

@@ -1,25 +1,30 @@
 /// Trait to be implemented on keys that encrypts clear values into ciphertexts
+#[allow(dead_code)]
 pub(crate) trait EncryptionKey<ClearType, CiphertextType> {
     /// The encryption process
     fn encrypt(&self, value: ClearType) -> CiphertextType;
 }
 
 /// Trait to be implemented on keys that decrypts ciphertext into clear values
+#[allow(dead_code)]
 pub(crate) trait DecryptionKey<CiphertextType, ClearType> {
     /// The decryption process
     fn decrypt(&self, ciphertext: &CiphertextType) -> ClearType;
 }
 
+#[allow(dead_code)]
 pub trait FromParameters<P> {
     fn from_parameters(parameters: P) -> Self;
 }
 
+#[allow(dead_code)]
 pub trait ParameterType: Clone {
     /// The Id allows to differentiate the different parameters
     /// as well as retrieving the corresponding client key and server key
     type Id: Copy;
 }
 
+#[allow(dead_code)]
 pub trait TypeIdentifier {
     fn type_variant(&self) -> crate::high_level_api::errors::Type;
 }

tfhe/src/high_level_api/keys/mod.rs

@@ -6,6 +6,7 @@ mod server;
 
 use crate::high_level_api::config::Config;
 pub use client::{ClientKey, RefKeyFromKeyChain};
+#[allow(unused_imports)]
 pub use public::{
     CompactPublicKey, CompressedCompactPublicKey, CompressedPublicKey, PublicKey,
     RefKeyFromCompressedPublicKeyChain, RefKeyFromPublicKeyChain,

tfhe/src/high_level_api/keys/public.rs

@@ -53,6 +53,7 @@ impl PublicKey {
 /// in the `PublicKey`.
 ///
 /// This is to allow the writing of generic functions.
+#[allow(dead_code)]
 pub trait RefKeyFromPublicKeyChain: Sized {
     type Key;
 
@@ -141,6 +142,7 @@ impl CompressedPublicKey {
     }
 }
 
+#[allow(dead_code)]
 pub trait RefKeyFromCompressedPublicKeyChain: Sized {
     type Key;
 

tfhe/src/high_level_api/mod.rs

@@ -24,6 +24,7 @@ macro_rules! expand_pub_use_fhe_type(
     }
 );
 
+#[allow(unused_imports)]
 pub use crate::core_crypto::commons::math::random::Seed;
 pub use config::{Config, ConfigBuilder};
 pub use errors::{Error, OutOfRangeError};

tfhe/src/js_on_wasm_api/shortint.rs

@@ -352,7 +352,7 @@ impl Shortint {
 
         let mut seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(Seed(seed));
         crate::shortint::engine::ShortintEngine::new_from_seeder(&mut seeder)
-            .new_client_key(parameters.0.try_into().unwrap())
+            .new_client_key(parameters.0.into())
             .map_err(|e| wasm_bindgen::JsError::new(format!("{e:?}").as_str()))
             .map(ShortintClientKey)
     }

tfhe/src/lib.rs

@@ -3,7 +3,13 @@
 //! TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE.
 
 #![cfg_attr(feature = "__wasm_api", allow(dead_code))]
-#![cfg_attr(feature = "nightly-avx512", feature(stdsimd, avx512_target_feature))]
+#![cfg_attr(
+    all(
+        any(target_arch = "x86", target_arch = "x86_64"),
+        feature = "nightly-avx512"
+    ),
+    feature(avx512_target_feature, stdarch_x86_avx512)
+)]
 #![cfg_attr(all(doc, not(doctest)), feature(doc_auto_cfg))]
 #![cfg_attr(all(doc, not(doctest)), feature(doc_cfg))]
 #![warn(rustdoc::broken_intra_doc_links)]

tfhe/src/shortint/parameters/parameters_wopbs_prime_moduli.rs

@@ -1,3 +1,4 @@
+#[allow(unused_imports)]
 pub use crate::core_crypto::commons::dispersion::{DispersionParameter, StandardDev};
 pub use crate::core_crypto::commons::parameters::{
     DecompositionBaseLog, DecompositionLevelCount, GlweDimension, LweDimension, PolynomialSize,

toolchain.txt

@@ -1 +1 @@
-nightly-2023-08-28
+nightly-2024-02-13