fix clippy issues

Zokrates · Apr 3, 2024 · deabda2 · deabda2
1 parent f102933
commit deabda2
Show file tree

Hide file tree

Showing 11 changed files with 31 additions and 56 deletions.
diff --git a/zokrates_analysis/src/flatten_complex_types.rs b/zokrates_analysis/src/flatten_complex_types.rs
@@ -1087,8 +1087,7 @@ fn fold_field_expression<'ast, T: Field>(
  .fold_identifier_expression(typed::ConcreteType::FieldElement, id)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::FieldElementExpression::Add(e) => {
  zir::FieldElementExpression::Add(f.fold_binary_expression(statements_buffer, e))
  }
@@ -1134,27 +1133,23 @@ fn fold_field_expression<'ast, T: Field>(
  .fold_conditional_expression(statements_buffer, c)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::FieldElementExpression::FunctionCall(..) => unreachable!(""),
  typed::FieldElementExpression::Select(select) => f
  .fold_select_expression(statements_buffer, select)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::FieldElementExpression::Member(m) => f
  .fold_member_expression(statements_buffer, m)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::FieldElementExpression::Element(element) => f
  .fold_element_expression(statements_buffer, element)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::FieldElementExpression::Block(block) => {
  block
  .statements
@@ -1239,8 +1234,7 @@ fn fold_boolean_expression<'ast, T: Field>(
  .fold_identifier_expression(typed::ConcreteType::Boolean, id)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::BooleanExpression::FieldEq(e) => f.fold_eq_expression(statements_buffer, e),
  typed::BooleanExpression::BoolEq(e) => f.fold_eq_expression(statements_buffer, e),
  typed::BooleanExpression::ArrayEq(e) => f.fold_eq_expression(statements_buffer, e),
@@ -1272,27 +1266,23 @@ fn fold_boolean_expression<'ast, T: Field>(
  .fold_conditional_expression(statements_buffer, c)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::BooleanExpression::FunctionCall(..) => unreachable!(),
  typed::BooleanExpression::Select(select) => f
  .fold_select_expression(statements_buffer, select)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::BooleanExpression::Member(m) => f
  .fold_member_expression(statements_buffer, m)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  typed::BooleanExpression::Element(m) => f
  .fold_element_expression(statements_buffer, m)
  .pop()
  .unwrap()
- .try_into()
- .unwrap(),
+ .into(),
  }
  .span(span)
 }
@@ -1327,8 +1317,7 @@ fn fold_uint_expression_inner<'ast, T: Field>(
  }
  typed::UExpressionInner::Value(v) => zir::UExpressionInner::Value(v),
  typed::UExpressionInner::Identifier(id) => {
- zir::UExpression::try_from(f.fold_identifier_expression(bitwidth, id).pop().unwrap())
- .unwrap()
+ zir::UExpression::from(f.fold_identifier_expression(bitwidth, id).pop().unwrap())
  .into_inner()
  }
  typed::UExpressionInner::Add(e) => {
@@ -1411,33 +1400,29 @@ fn fold_uint_expression_inner<'ast, T: Field>(
  typed::UExpressionInner::FunctionCall(..) => {
  unreachable!("function calls should have been removed")
  }
- typed::UExpressionInner::Select(select) => zir::UExpression::try_from(
+ typed::UExpressionInner::Select(select) => zir::UExpression::from(
  f.fold_select_expression(statements_buffer, select)
  .pop()
  .unwrap(),
  )
- .unwrap()
  .into_inner(),
- typed::UExpressionInner::Member(m) => zir::UExpression::try_from(
+ typed::UExpressionInner::Member(m) => zir::UExpression::from(
  f.fold_member_expression(statements_buffer, m)
  .pop()
  .unwrap(),
  )
- .unwrap()
  .into_inner(),
- typed::UExpressionInner::Element(m) => zir::UExpression::try_from(
+ typed::UExpressionInner::Element(m) => zir::UExpression::from(
  f.fold_element_expression(statements_buffer, m)
  .pop()
  .unwrap(),
  )
- .unwrap()
  .into_inner(),
- typed::UExpressionInner::Conditional(c) => zir::UExpression::try_from(
+ typed::UExpressionInner::Conditional(c) => zir::UExpression::from(
  f.fold_conditional_expression(statements_buffer, c)
  .pop()
  .unwrap(),
  )
- .unwrap()
  .into_inner(),
  }
  .span(span)

diff --git a/zokrates_analysis/src/propagation.rs b/zokrates_analysis/src/propagation.rs
@@ -357,8 +357,7 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for Propagator<'ast, T> {
  let argument = arguments.last().cloned().unwrap();
  let argument = argument.into_canonical_constant();
 
- match ArrayExpression::try_from(argument)
- .unwrap()
+ match ArrayExpression::from(argument)
  .into_inner()
  {
  ArrayExpressionInner::Value(v) =>
@@ -397,10 +396,7 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for Propagator<'ast, T> {
  ) -> TypedExpression<'ast, T> {
  assert_eq!(arguments.len(), 1);
 
- match UExpression::try_from(arguments[0].clone())
- .unwrap()
- .into_inner()
- {
+ match UExpression::from(arguments[0].clone()).into_inner() {
  UExpressionInner::Value(v) => {
  let mut num = v.value;
  let mut res = vec![];
@@ -493,11 +489,9 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for Propagator<'ast, T> {
 
  let bit_width = embed_call.generics[0];
 
- match FieldElementExpression::<T>::try_from(
+ match FieldElementExpression::<T>::from(
  embed_call.arguments[0].clone(),
- )
- .unwrap()
- {
+ ) {
  FieldElementExpression::Value(num) => {
  let mut acc = num.value;
  let mut res = vec![];
@@ -1197,7 +1191,7 @@ impl<'ast, T: Field> ResultFolder<'ast, T> for Propagator<'ast, T> {
  // clone only the element
  match v.value[n.value as usize].clone() {
  TypedExpressionOrSpread::Expression(e) => {
- E::try_from(e).unwrap().into_inner()
+ E::from(e).into_inner()
  }
  _ => unreachable!(),
  },

diff --git a/zokrates_analysis/src/reducer/constants_reader.rs b/zokrates_analysis/src/reducer/constants_reader.rs
@@ -8,8 +8,6 @@ use zokrates_ast::typed::{
 };
 use zokrates_field::Field;
 
-use std::convert::TryFrom;
-
 pub struct ConstantsReader<'a, 'ast, T> {
  constants: &'a ConstantDefinitions<'ast, T>,
 }
@@ -41,7 +39,7 @@ impl<'a, 'ast, T: Field> Folder<'ast, T> for ConstantsReader<'a, 'ast, T> {
  let c = self.fold_canonical_constant_identifier(c);
 
  match self.constants.get(&c).cloned() {
- Some(e) => match UExpression::try_from(e).unwrap().into_inner() {
+ Some(e) => match UExpression::from(e).into_inner() {
  UExpressionInner::Value(v) => DeclarationConstant::Concrete(v.value as u32),
  _ => unreachable!(),
  },

diff --git a/zokrates_analysis/src/reducer/mod.rs b/zokrates_analysis/src/reducer/mod.rs
@@ -245,7 +245,7 @@ impl<'ast, 'a, T: Field> ResultFolder<'ast, T> for Reducer<'ast, 'a, T> {
  self.statement_buffer.extend(definition);
 
  let e = match self.propagator.constants.get(&identifier) {
- Some(v) => E::try_from(v.clone()).unwrap().into_inner(),
+ Some(v) => E::from(v.clone()).into_inner(),
  None => E::identifier(identifier),
  };
 

diff --git a/zokrates_ast/src/ir/expression.rs b/zokrates_ast/src/ir/expression.rs
@@ -217,8 +217,8 @@ impl<T: Field> LinComb<T> {
 
  pub fn is_assignee(&self, witness: &Witness<T>) -> bool {
  self.value.len() == 1
- && self.value.get(0).unwrap().1 == T::from(1)
- && !witness.0.contains_key(&self.value.get(0).unwrap().0)
+ && self.value.first().unwrap().1 == T::from(1)
+ && !witness.0.contains_key(&self.value.first().unwrap().0)
  }
 
  pub fn try_summand(self) -> Result<(Variable, T), Self> {

diff --git a/zokrates_ast/src/lib.rs b/zokrates_ast/src/lib.rs
@@ -1,5 +1,5 @@
 // see https://github.com/mcarton/rust-derivative/issues/115
-#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 pub mod common;
 pub mod flat;

diff --git a/zokrates_ast/src/typed/integer.rs b/zokrates_ast/src/typed/integer.rs
@@ -14,7 +14,6 @@ use crate::typed::{
 use crate::common::{operators::*, WithSpan};
 
 use num_bigint::BigUint;
-use std::convert::TryFrom;
 use std::fmt;
 use std::ops::*;
 use zokrates_field::Field;
@@ -581,7 +580,7 @@ impl<'ast, T: Field> FieldElementExpression<'ast, T> {
  )
  .map_err(|(e, _)| match e {
  TypedExpressionOrSpread::Expression(e) => {
- IntExpression::try_from(e).unwrap()
+ IntExpression::from(e)
  }
  TypedExpressionOrSpread::Spread(a) => {
  IntExpression::select(a.array, 0u32)
@@ -704,7 +703,7 @@ impl<'ast, T: Field> UExpression<'ast, T> {
  )
  .map_err(|(e, _)| match e {
  TypedExpressionOrSpread::Expression(e) => {
- IntExpression::try_from(e).unwrap()
+ IntExpression::from(e)
  }
  TypedExpressionOrSpread::Spread(a) => {
  IntExpression::select(a.array, 0u32)

diff --git a/zokrates_ast/src/typed/mod.rs b/zokrates_ast/src/typed/mod.rs
@@ -1771,8 +1771,7 @@ impl<'ast, T: Field> ArrayValueExpression<'ast, T> {
  .nth(index)
  .unwrap()
  .clone()
- .try_into()
- .unwrap()
+ .into()
  }
 }
 

diff --git a/zokrates_ast/src/typed/types.rs b/zokrates_ast/src/typed/types.rs
@@ -251,7 +251,7 @@ impl<'ast, T: Field> From<DeclarationConstant<'ast, T>> for UExpression<'ast, T>
  DeclarationConstant::Constant(v) => {
  UExpression::identifier(FrameIdentifier::from(v).into()).annotate(UBitwidth::B32)
  }
- DeclarationConstant::Expression(e) => e.try_into().unwrap(),
+ DeclarationConstant::Expression(e) => e.into(),
  }
  }
 }

diff --git a/zokrates_bellperson/src/nova.rs b/zokrates_bellperson/src/nova.rs
@@ -221,7 +221,7 @@ impl<'ast, T: Field + BellpersonFieldExtensions + Cycle> StepCircuit<T::Bellpers
  // populate the witness if we got some input values
  // this is a bit hacky and in particular generates the witness in all cases if there are no inputs
  if input
- .get(0)
+ .first()
  .map(|n| n.get_value().is_some())
  .unwrap_or(true)
  {

diff --git a/zokrates_interpreter/src/lib.rs b/zokrates_interpreter/src/lib.rs
@@ -71,7 +71,7 @@ impl Interpreter {
  Statement::Constraint(s) => match s.lin.is_assignee(&witness) {
  true => {
  let val = evaluate_quad(&witness, &s.quad).unwrap();
- witness.insert(s.lin.value.get(0).unwrap().0, val);
+ witness.insert(s.lin.value.first().unwrap().0, val);
  }
  false => {
  let lhs_value = evaluate_quad(&witness, &s.quad).unwrap();