chore(backward): move allow(dead_code) to dispatch variants

This allows to detect unused dispatch enums

tfhe-zk-pok/src/backward_compatibility/mod.rs

@@ -60,14 +60,14 @@ impl Display for IncompleteProof {
 impl Error for IncompleteProof {}
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum GroupElementsVersions<G: Curve> {
+    #[allow(dead_code)]
     V0(GroupElements<G>),
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum SerializableGroupElementsVersions {
+    #[allow(dead_code)]
     V0(SerializableGroupElements),
 }
 

tfhe-zk-pok/src/backward_compatibility/pke.rs

@@ -49,8 +49,8 @@ pub enum ProofVersions<G: Curve> {
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum ComputeLoadProofFieldVersions<G: Curve> {
+    #[allow(dead_code)]
     V0(ComputeLoadProofFields<G>),
 }
 
@@ -107,11 +107,11 @@ where
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum CompressedComputeLoadProofFieldsVersions<G: Curve>
 where
     G::G1: Compressible,
     G::G2: Compressible,
 {
+    #[allow(dead_code)]
     V0(CompressedComputeLoadProofFields<G>),
 }

tfhe/src/integer/backward_compatibility/ciphertext/mod.rs

@@ -77,8 +77,8 @@ pub enum CompressedModulusSwitchedRadixCiphertextVersions {
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum CompressedModulusSwitchedRadixCiphertextGenericVersions {
+    #[allow(dead_code)]
     V0(CompressedModulusSwitchedRadixCiphertextGeneric),
 }
 

tfhe/src/shortint/backward_compatibility/ciphertext/mod.rs

@@ -134,8 +134,8 @@ pub enum CompressedModulusSwitchedCiphertextVersions {
 }
 
 #[derive(VersionsDispatch)]
-#[allow(dead_code)]
 pub(crate) enum InternalCompressedModulusSwitchedCiphertextVersions {
+    #[allow(dead_code)]
     V0(InternalCompressedModulusSwitchedCiphertext),
 }
 

utils/tfhe-versionable/examples/manual_impl.rs

@@ -84,9 +84,10 @@ impl<T: Unversionize + Serialize + for<'de> Deserialize<'de> + Default> Unversio
 // Since MyStructV0 is only composed of built-in types, it does not need recursive versioning and
 // can be used as its own "version type".
 #[derive(Serialize)]
-#[allow(dead_code)]
 enum MyStructVersionsDispatch<'vers, T: 'vers + Versionize> {
+    #[allow(dead_code)]
     V0(MyStructV0),
+    #[allow(dead_code)]
     V1(MyStructVersion<'vers, T>),
 }
 

utils/tfhe-versionable/examples/transparent_then_not.rs

@@ -22,8 +22,8 @@ struct MyStructWrapper<T> {
     count: u64,
 }
 
-// We need to create a dispatch enum that has the same history as the inner type until the point
-// where the wrapper is not transparent anymore.
+// We need to create a dispatch enum that follows the version numbers of the inner type, until the
+// point where the wrapper is not transparent anymore.
 #[derive(VersionsDispatch)]
 #[allow(unused)]
 enum MyStructWrapperVersions<T> {

utils/tfhe-versionable/tests/bounds_private_in_public.rs

@@ -30,8 +30,8 @@ mod mymod {
     struct Private<T>(T);
 
     #[derive(VersionsDispatch)]
-    #[allow(dead_code)]
     enum PrivateVersions<T> {
+        #[allow(dead_code)]
         V0(Private<T>),
     }
 }