Lint: fix all warnings for Rust 1.84

Author: dannywillems

Cargo.toml

@@ -28,6 +28,11 @@ members = [
 ]
 resolver = "2"
 
+# Ignore non-local impl warnings from OCaml derive macros in nested contexts
+# See: https://github.com/o1-labs/proof-systems/issues/3319
+[workspace.lints.rust]
+non_local_definitions = "allow"
+
 [workspace.dependencies]
 ark-algebra-test-templates = "0.5"
 ark-bn254 = { version = "0.5" }

arrabbiata/src/challenge.rs

@@ -142,6 +142,6 @@ impl<F> Index<ChallengeTerm> for Challenges<F> {
     }
 }
 
-impl<'a> AlphaChallengeTerm<'a> for ChallengeTerm {
+impl AlphaChallengeTerm<'_> for ChallengeTerm {
     const ALPHA: Self = Self::ConstraintCombiner;
 }

curves/Cargo.toml

@@ -9,6 +9,9 @@ readme = "../README.md"
 edition = "2021"
 license = "Apache-2.0"
 
+[features]
+asm = ["ark-ff/asm"]
+
 [dependencies]
 ark-bn254.workspace = true
 ark-ec.workspace = true

folding/src/eval_leaf.rs

@@ -6,7 +6,7 @@ pub enum EvalLeaf<'a, F> {
     Result(Vec<F>),
 }
 
-impl<'a, F: core::fmt::Display> core::fmt::Display for EvalLeaf<'a, F> {
+impl<F: core::fmt::Display> core::fmt::Display for EvalLeaf<'_, F> {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let slice = match self {
             EvalLeaf::Const(c) => {
@@ -25,39 +25,39 @@ impl<'a, F: core::fmt::Display> core::fmt::Display for EvalLeaf<'a, F> {
     }
 }
 
-impl<'a, F: core::ops::Add<Output = F> + Clone> core::ops::Add for EvalLeaf<'a, F> {
+impl<F: core::ops::Add<Output = F> + Clone> core::ops::Add for EvalLeaf<'_, F> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self {
         Self::bin_op(|a, b| a + b, self, rhs)
     }
 }
 
-impl<'a, F: core::ops::Sub<Output = F> + Clone> core::ops::Sub for EvalLeaf<'a, F> {
+impl<F: core::ops::Sub<Output = F> + Clone> core::ops::Sub for EvalLeaf<'_, F> {
     type Output = Self;
 
     fn sub(self, rhs: Self) -> Self {
         Self::bin_op(|a, b| a - b, self, rhs)
     }
 }
 
-impl<'a, F: core::ops::Mul<Output = F> + Clone> core::ops::Mul for EvalLeaf<'a, F> {
+impl<F: core::ops::Mul<Output = F> + Clone> core::ops::Mul for EvalLeaf<'_, F> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self {
         Self::bin_op(|a, b| a * b, self, rhs)
     }
 }
 
-impl<'a, F: core::ops::Mul<Output = F> + Clone> core::ops::Mul<F> for EvalLeaf<'a, F> {
+impl<F: core::ops::Mul<Output = F> + Clone> core::ops::Mul<F> for EvalLeaf<'_, F> {
     type Output = Self;
 
     fn mul(self, rhs: F) -> Self {
         self * Self::Const(rhs)
     }
 }
 
-impl<'a, F: Clone> EvalLeaf<'a, F> {
+impl<F: Clone> EvalLeaf<'_, F> {
     pub fn map<M: Fn(&F) -> F, I: Fn(&mut F)>(self, map: M, in_place: I) -> Self {
         use EvalLeaf::*;
         match self {

internal-tracing/Cargo.toml

@@ -4,6 +4,9 @@ version = "0.1.0"
 edition = "2021"
 license = "Apache-2.0"
 
+[lints]
+workspace = true
+
 [dependencies]
 ocaml = { workspace = true, optional = true }
 ocaml-gen = { workspace = true, optional = true }

ivc/tests/simple.rs

@@ -80,6 +80,26 @@ impl ColumnIndexer<usize> for AdditionColumn {
     }
 }
 
+impl FoldingColumnTrait for AdditionColumn {
+    fn is_witness(&self) -> bool {
+        true
+    }
+}
+
+impl<const N_COL: usize, const N_FSEL: usize> Index<AdditionColumn>
+    for PlonkishWitness<N_COL, N_FSEL, Fp>
+{
+    type Output = [Fp];
+
+    fn index(&self, index: AdditionColumn) -> &Self::Output {
+        match index {
+            AdditionColumn::A => &self.witness.cols[0].evals,
+            AdditionColumn::B => &self.witness.cols[1].evals,
+            AdditionColumn::C => &self.witness.cols[2].evals,
+        }
+    }
+}
+
 /// Simply compute A + B - C
 pub fn interpreter_simple_add<
     F: PrimeField,
@@ -153,12 +173,6 @@ pub fn heavy_test_simple_add() {
 
     // ---- Defining the folding configuration ----
     // FoldingConfig
-    impl FoldingColumnTrait for AdditionColumn {
-        fn is_witness(&self) -> bool {
-            true
-        }
-    }
-
     type AppWitnessBuilderEnv = WitnessBuilderEnv<
         Fp,
         AdditionColumn,
@@ -169,20 +183,6 @@ pub fn heavy_test_simple_add() {
         DummyLookupTable,
     >;
 
-    impl<const N_COL: usize, const N_FSEL: usize> Index<AdditionColumn>
-        for PlonkishWitness<N_COL, N_FSEL, Fp>
-    {
-        type Output = [Fp];
-
-        fn index(&self, index: AdditionColumn) -> &Self::Output {
-            match index {
-                AdditionColumn::A => &self.witness.cols[0].evals,
-                AdditionColumn::B => &self.witness.cols[1].evals,
-                AdditionColumn::C => &self.witness.cols[2].evals,
-            }
-        }
-    }
-
     type Config<
         const N_COL_TOTAL: usize,
         const N_CHALS: usize,

kimchi-stubs/Cargo.toml

@@ -7,13 +7,19 @@ repository = "https://github.com/MinaProtocol/mina"
 license = "MIT/Apache-2.0"
 edition = "2021"
 
+[lints]
+workspace = true
+
 [lib]
 name = "kimchi_stubs"
 # Important: do not ask to build a dynamic library.
 # On MacOS arm64, ocaml-rs.v0.2.2 causes build issues.
 # On the Mina side, a fake and empty dllkimchi_stubs.so file is used.
 crate-type = ["lib", "staticlib"]
 
+[features]
+no-std = []
+
 [dependencies]
 libc.workspace = true
 num-bigint = { workspace = true, features = ["rand", "serde"] }

kimchi-stubs/src/arkworks/bigint_256.rs

@@ -32,7 +32,7 @@ impl From<BigInteger256> for CamlBigInteger256 {
     }
 }
 
-unsafe impl<'a> ocaml::FromValue<'a> for CamlBigInteger256 {
+unsafe impl ocaml::FromValue<'_> for CamlBigInteger256 {
     fn from_value(value: ocaml::Value) -> Self {
         let x: ocaml::Pointer<Self> = ocaml::FromValue::from_value(value);
         *x.as_ref()

kimchi-stubs/src/arkworks/group_projective.rs

@@ -6,7 +6,7 @@ use mina_curves::pasta::curves::{pallas::ProjectivePallas, vesta::ProjectiveVest
 #[derive(Clone, Copy, ocaml_gen::CustomType)]
 pub struct CamlGroupProjectivePallas(pub ProjectivePallas);
 
-unsafe impl<'a> ocaml::FromValue<'a> for CamlGroupProjectivePallas {
+unsafe impl ocaml::FromValue<'_> for CamlGroupProjectivePallas {
     fn from_value(value: ocaml::Value) -> Self {
         let x: ocaml::Pointer<Self> = ocaml::FromValue::from_value(value);
         *x.as_ref()
@@ -111,7 +111,7 @@ impl Neg for &CamlGroupProjectivePallas {
 #[derive(Clone, Copy, ocaml_gen::CustomType)]
 pub struct CamlGroupProjectiveVesta(pub ProjectiveVesta);
 
-unsafe impl<'a> ocaml::FromValue<'a> for CamlGroupProjectiveVesta {
+unsafe impl ocaml::FromValue<'_> for CamlGroupProjectiveVesta {
     fn from_value(value: ocaml::Value) -> Self {
         let x: ocaml::Pointer<Self> = ocaml::FromValue::from_value(value);
         *x.as_ref()

kimchi-stubs/src/arkworks/pasta_fp.rs

@@ -17,7 +17,7 @@ use rand::rngs::StdRng;
 #[derive(Clone, Copy, Debug, ocaml_gen::CustomType)]
 pub struct CamlFp(pub Fp);
 
-unsafe impl<'a> ocaml::FromValue<'a> for CamlFp {
+unsafe impl ocaml::FromValue<'_> for CamlFp {
     fn from_value(value: ocaml::Value) -> Self {
         let x: ocaml::Pointer<Self> = ocaml::FromValue::from_value(value);
         *x.as_ref()