github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-23 20:28:36 +00:00
Code Issues Projects Releases Wiki Activity

merge clippy

Browse source
This commit is contained in:
schaeff 2020-12-20 20:30:40 +01:00
parent 5fa236d26d
commit 1938a98d2a
59 changed files with 436 additions and 475 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.circleci/config.yml
View file

@ -75,12 +75,11 @@ jobs:
- v4-cargo-cache-{{ arch }}-{{ checksum "Cargo.lock" }}
- run:
name: Test on firefox
command: GECKODRIVER=geckodriver cd zokrates_core && wasm-pack test --firefox --headless -- --no-default-features --features "wasm bellman"
command: cd zokrates_core && wasm-pack test --firefox --headless -- --no-default-features --features "wasm bellman"
integration_test:
docker:
- image: zokrates/env:latest
- image: trufflesuite/ganache-cli:next
port: 8545:8545
steps:
- checkout
- run:

12
Cargo.lock generated
View file

@ -2087,7 +2087,7 @@ dependencies = [
[[package]]
name = "zokrates_abi"
version = "0.1.2"
version = "0.1.3"
dependencies = [
"serde",
"serde_derive",
@ -2098,7 +2098,7 @@ dependencies = [
[[package]]
name = "zokrates_cli"
version = "0.6.2"
version = "0.6.3"
dependencies = [
"assert_cli",
"bincode",
@ -2122,7 +2122,7 @@ version = "0.1.0"
[[package]]
name = "zokrates_core"
version = "0.5.2"
version = "0.5.3"
dependencies = [
"ark-bls12-377",
"ark-bn254",
@ -2161,7 +2161,7 @@ dependencies = [
[[package]]
name = "zokrates_core_test"
version = "0.1.3"
version = "0.1.4"
dependencies = [
"zokrates_test",
"zokrates_test_derive",
@ -2199,7 +2199,7 @@ dependencies = [
[[package]]
name = "zokrates_parser"
version = "0.1.5"
version = "0.1.6"
dependencies = [
"glob 0.2.11",
"pest",
@ -2208,7 +2208,7 @@ dependencies = [
[[package]]
name = "zokrates_pest_ast"
version = "0.1.4"
version = "0.1.5"
dependencies = [
"from-pest",
"glob 0.2.11",

7
Dockerfile
View file

@ -9,10 +9,9 @@ RUN cd src; ./build_release.sh
FROM ubuntu:18.04
ENV ZOKRATES_HOME=/home/zokrates/.zokrates
COPY --from=build /build/src/scripts/install_libsnark_prerequisites.sh /tmp/
RUN /tmp/install_libsnark_prerequisites.sh \
&& useradd -u 1000 -m zokrates
RUN apt-get update \
&& apt-get install -y --no-install-recommends libgmp3-dev \
&& useradd -u 1000 -m zokrates
USER zokrates
WORKDIR /home/zokrates

12
Dockerfile.env
View file

@ -22,20 +22,24 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
clang-format \
python3 \
python-markdown \
&& add-apt-repository ppa:jonathonf/firefox-esr; apt-get install -y firefox-esr \
&& add-apt-repository ppa:mozillateam/ppa \
&& apt-get update \
&& apt-get install -y --no-install-recommends firefox-esr \
&& ln -s /usr/bin/firefox-esr /usr/bin/firefox \
&& rm -rf /var/lib/apt/lists/*
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --default-toolchain none -y \
&& rustup toolchain install nightly --allow-downgrade --profile minimal --component rustfmt \
&& cargo install --git https://github.com/rustwasm/wasm-pack \
&& rm -rf /usr/local/cargo/registry \
&& curl -sL https://deb.nodesource.com/setup_lts.x | bash - && apt-get install -y nodejs && npm i -g solc \
&& curl -sL https://raw.githubusercontent.com/Sarcasm/run-clang-format/master/run-clang-format.py > /opt/run-clang-format.py \
&& chmod +x /opt/run-clang-format.py \
&& ln -s /opt/run-clang-format.py /usr/bin \
&& rustup --version; cargo --version; rustc --version; wasm-pack --version; echo nodejs $(node -v);
RUN cd /opt && curl -LO https://github.com/mozilla/geckodriver/releases/download/v0.26.0/geckodriver-v0.26.0-linux64.tar.gz \
&& tar -xzf geckodriver-v0.26.0-linux64.tar.gz geckodriver \
RUN cd /opt && curl -LO https://github.com/mozilla/geckodriver/releases/download/v0.28.0/geckodriver-v0.28.0-linux64.tar.gz \
&& tar -xzf geckodriver-v0.28.0-linux64.tar.gz geckodriver \
&& ln -s /opt/geckodriver /usr/bin \
&& geckodriver --version \
&& rm -rf geckodriver-v0.26.0-linux64.tar.gz
&& rm -rf geckodriver-v0.28.0-linux64.tar.gz

2
zokrates_abi/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_abi"
version = "0.1.2"
version = "0.1.3"
authors = ["Thibaut Schaeffer <thibaut@schaeff.fr>"]
edition = "2018"

44
zokrates_abi/src/lib.rs
View file

@ -248,9 +248,9 @@ impl<T: Field> TryFrom<serde_json::Value> for Values<T> {
match v {
serde_json::Value::Array(a) => a
.into_iter()
.map(|v| Value::try_from(v))
.map(Value::try_from)
.collect::<Result<_, _>>()
.map(|v| Values(v)),
.map(Values),
v => Err(format!("Expected an array of values, found `{}`", v)),
}
}
@ -260,20 +260,22 @@ impl<T: Field> TryFrom<serde_json::Value> for Value<T> {
type Error = String;
fn try_from(v: serde_json::Value) -> Result<Value<T>, Self::Error> {
match v {
serde_json::Value::String(s) => T::try_from_dec_str(&s)
.map(|v| Value::Field(v))
.or_else(|_| match s.len() {
4 => u8::from_str_radix(&s[2..], 16)
.map(|v| Value::U8(v))
.map_err(|_| format!("Expected u8 value, found {}", s)),
6 => u16::from_str_radix(&s[2..], 16)
.map(|v| Value::U16(v))
.map_err(|_| format!("Expected u16 value, found {}", s)),
10 => u32::from_str_radix(&s[2..], 16)
.map(|v| Value::U32(v))
.map_err(|_| format!("Expected u32 value, found {}", s)),
_ => Err(format!("Cannot parse {} to any type", s)),
}),
serde_json::Value::String(s) => {
T::try_from_dec_str(&s)
.map(Value::Field)
.or_else(|_| match s.len() {
4 => u8::from_str_radix(&s[2..], 16)
.map(Value::U8)
.map_err(|_| format!("Expected u8 value, found {}", s)),
6 => u16::from_str_radix(&s[2..], 16)
.map(Value::U16)
.map_err(|_| format!("Expected u16 value, found {}", s)),
10 => u32::from_str_radix(&s[2..], 16)
.map(Value::U32)
.map_err(|_| format!("Expected u32 value, found {}", s)),
_ => Err(format!("Cannot parse {} to any type", s)),
})
}
serde_json::Value::Bool(b) => Ok(Value::Boolean(b)),
serde_json::Value::Number(n) => Err(format!(
"Value `{}` isn't allowed, did you mean `\"{}\"`?",
@ -281,14 +283,14 @@ impl<T: Field> TryFrom<serde_json::Value> for Value<T> {
)),
serde_json::Value::Array(a) => a
.into_iter()
.map(|v| Value::try_from(v))
.map(Value::try_from)
.collect::<Result<_, _>>()
.map(|v| Value::Array(v)),
.map(Value::Array),
serde_json::Value::Object(o) => o
.into_iter()
.map(|(k, v)| Value::try_from(v).map(|v| (k, v)))
.collect::<Result<Map<_, _>, _>>()
.map(|v| Value::Struct(v)),
.map(Value::Struct),
v => Err(format!("Value `{}` isn't allowed", v)),
}
}
@ -321,7 +323,7 @@ impl<T: Field> Into<serde_json::Value> for CheckedValues<T> {
fn parse<T: Field>(s: &str) -> Result<Values<T>, Error> {
let json_values: serde_json::Value =
serde_json::from_str(s).map_err(|e| Error::Json(e.to_string()))?;
Values::try_from(json_values).map_err(|e| Error::Conversion(e))
Values::try_from(json_values).map_err(Error::Conversion)
}
pub fn parse_strict<T: Field>(
@ -342,7 +344,7 @@ pub fn parse_strict<T: Field>(
.zip(types.into_iter())
.map(|(v, ty)| v.check(ty))
.collect::<Result<Vec<_>, _>>()
.map_err(|e| Error::Type(e))?;
.map_err(Error::Type)?;
Ok(CheckedValues(checked))
}

2
zokrates_cli/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_cli"
version = "0.6.2"
version = "0.6.3"
authors = ["Jacob Eberhardt <jacob.eberhardt@tu-berlin.de>", "Dennis Kuhnert <mail@kyroy.com>", "Thibaut Schaeffer <thibaut@schaeff.fr>"]
repository = "https://github.com/JacobEberhardt/ZoKrates.git"
edition = "2018"

2
zokrates_cli/build.rs
View file

@ -11,5 +11,5 @@ fn export_stdlib() {
let out_dir = env::var("OUT_DIR").unwrap();
let mut options = CopyOptions::new();
options.overwrite = true;
copy_items(&vec!["tests/contract"], out_dir, &options).unwrap();
copy_items(&["tests/contract"], out_dir, &options).unwrap();
}

15
zokrates_cli/src/bin.rs
View file

@ -84,7 +84,7 @@ fn cli_generate_proof<T: Field, S: Scheme<T>, B: Backend<T, S>>(
.write(proof.as_bytes())
.map_err(|why| format!("Couldn't write to {}: {}", proof_path.display(), why))?;
println!("Proof:\n{}", format!("{}", proof));
println!("Proof:\n{}", proof);
Ok(())
}
@ -211,7 +211,7 @@ fn cli_compute<T: Field>(ir_prog: ir::Prog<T>, sub_matches: &ArgMatches) -> Resu
.collect::<Result<Vec<_>, _>>()
})
.unwrap_or(Ok(vec![]))
.map(|v| Inputs::Raw(v))
.map(Inputs::Raw)
}
// take stdin arguments
true => {
@ -224,7 +224,7 @@ fn cli_compute<T: Field>(ir_prog: ir::Prog<T>, sub_matches: &ArgMatches) -> Resu
use zokrates_abi::parse_strict;
parse_strict(&input, signature.inputs)
.map(|parsed| Inputs::Abi(parsed))
.map(Inputs::Abi)
.map_err(|why| why.to_string())
}
Err(_) => Err(String::from("???")),
@ -235,10 +235,10 @@ fn cli_compute<T: Field>(ir_prog: ir::Prog<T>, sub_matches: &ArgMatches) -> Resu
Ok(_) => {
input.retain(|x| x != '\n');
input
.split(" ")
.split(' ')
.map(|x| T::try_from_dec_str(x).map_err(|_| x.to_string()))
.collect::<Result<Vec<_>, _>>()
.map(|v| Inputs::Raw(v))
.map(Inputs::Raw)
}
Err(_) => Err(String::from("???")),
},
@ -460,7 +460,7 @@ fn cli() -> Result<(), String> {
let matches = App::new("ZoKrates")
.setting(AppSettings::SubcommandRequiredElseHelp)
.version(env!("CARGO_PKG_VERSION"))
.author("Jacob Eberhardt, Thibaut Schaeffer, Stefan Deml")
.author("Jacob Eberhardt, Thibaut Schaeffer, Stefan Deml, Darko Macesic")
.about("Supports generation of zkSNARKs from high level language code including Smart Contracts for proof verification on the Ethereum Blockchain.\n'I know that I show nothing!'")
.subcommand(SubCommand::with_name("compile")
.about("Compiles into flattened conditions. Produces two files: human-readable '.ztf' file for debugging and binary file")
@ -614,7 +614,6 @@ fn cli() -> Result<(), String> {
.short("s")
.long("proving-scheme")
.help("Proving scheme to use to export the verifier")
.value_name("FILE")
.takes_value(true)
.required(false)
.possible_values(SCHEMES)
@ -726,7 +725,6 @@ fn cli() -> Result<(), String> {
.short("s")
.long("proving-scheme")
.help("Proving scheme to use to generate the proof")
.value_name("FILE")
.takes_value(true)
.required(false)
.possible_values(SCHEMES)
@ -783,7 +781,6 @@ fn cli() -> Result<(), String> {
.short("s")
.long("proving-scheme")
.help("Proving scheme to use in the setup. Available options are G16 (default), PGHR13 and GM17")
.value_name("FILE")
.takes_value(true)
.required(false)
.default_value(&default_scheme)

30
zokrates_cli/src/constants.rs
View file

@ -9,27 +9,21 @@ pub const BACKENDS: &[&str] = if cfg!(feature = "libsnark") {
} else {
&[LIBSNARK, ARK]
}
} else if cfg!(feature = "bellman") {
&[BELLMAN, LIBSNARK]
} else {
if cfg!(feature = "bellman") {
&[BELLMAN, LIBSNARK]
} else {
&[LIBSNARK]
}
&[LIBSNARK]
}
} else if cfg!(feature = "ark") {
if cfg!(feature = "bellman") {
&[BELLMAN, ARK]
} else {
&[ARK]
}
} else if cfg!(feature = "bellman") {
&[BELLMAN]
} else {
if cfg!(feature = "ark") {
if cfg!(feature = "bellman") {
&[BELLMAN, ARK]
} else {
&[ARK]
}
} else {
if cfg!(feature = "bellman") {
&[BELLMAN]
} else {
&[]
}
}
&[]
};
pub const BN128: &str = "bn128";

10
zokrates_cli/tests/integration.rs
View file

@ -3,7 +3,7 @@ extern crate serde_json;
#[cfg(test)]
mod integration {
use assert_cli;
use serde_json::from_reader;
use std::fs;
use std::fs::File;
@ -147,11 +147,11 @@ mod integration {
.map_err(|why| why.to_string())
.unwrap();
let signature = abi.signature().clone();
let signature = abi.signature();
let inputs_abi: zokrates_abi::Inputs<zokrates_field::Bn128Field> =
parse_strict(&json_input_str, signature.inputs)
.map(|parsed| zokrates_abi::Inputs::Abi(parsed))
.map(zokrates_abi::Inputs::Abi)
.map_err(|why| why.to_string())
.unwrap();
let inputs_raw: Vec<_> = inputs_abi
@ -169,7 +169,7 @@ mod integration {
inline_witness_path.to_str().unwrap(),
];
if inputs_raw.len() > 0 {
if !inputs_raw.is_empty() {
compute_inline.push("-a");
for arg in &inputs_raw {
@ -202,7 +202,7 @@ mod integration {
assert_eq!(inline_witness, witness);
for line in expected_witness.as_str().split("\n") {
for line in expected_witness.as_str().split('\n') {
assert!(
witness.contains(line),
"Witness generation failed for {}\n\nLine \"{}\" not found in witness",

2
zokrates_core/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_core"
version = "0.5.2"
version = "0.5.3"
edition = "2018"
authors = ["Jacob Eberhardt <jacob.eberhardt@tu-berlin.de>", "Dennis Kuhnert <mail@kyroy.com>"]
repository = "https://github.com/JacobEberhardt/ZoKrates"

24
zokrates_core/src/absy/from_ast.rs
View file

@ -9,14 +9,14 @@ impl<'ast> From<pest::File<'ast>> for absy::Module<'ast> {
absy::Module::with_symbols(
prog.structs
.into_iter()
.map(|t| absy::SymbolDeclarationNode::from(t))
.map(absy::SymbolDeclarationNode::from)
.chain(
prog.functions
.into_iter()
.map(|f| absy::SymbolDeclarationNode::from(f)),
.map(absy::SymbolDeclarationNode::from),
),
)
.imports(prog.imports.into_iter().map(|i| absy::ImportNode::from(i)))
.imports(prog.imports.into_iter().map(absy::ImportNode::from))
}
}
@ -57,7 +57,7 @@ impl<'ast> From<pest::StructDefinition<'ast>> for absy::SymbolDeclarationNode<'a
fields: definition
.fields
.into_iter()
.map(|f| absy::StructDefinitionFieldNode::from(f))
.map(absy::StructDefinitionFieldNode::from)
.collect(),
}
.span(span.clone());
@ -104,7 +104,7 @@ impl<'ast> From<pest::Function<'ast>> for absy::SymbolDeclarationNode<'ast> {
.returns
.clone()
.into_iter()
.map(|r| absy::UnresolvedTypeNode::from(r))
.map(absy::UnresolvedTypeNode::from)
.collect(),
);
@ -119,12 +119,12 @@ impl<'ast> From<pest::Function<'ast>> for absy::SymbolDeclarationNode<'ast> {
arguments: function
.parameters
.into_iter()
.map(|a| absy::ParameterNode::from(a))
.map(absy::ParameterNode::from)
.collect(),
statements: function
.statements
.into_iter()
.flat_map(|s| statements_from_statement(s))
.flat_map(statements_from_statement)
.collect(),
signature,
}
@ -261,7 +261,7 @@ impl<'ast> From<pest::ReturnStatement<'ast>> for absy::StatementNode<'ast> {
expressions: statement
.expressions
.into_iter()
.map(|e| absy::ExpressionNode::from(e))
.map(absy::ExpressionNode::from)
.collect(),
}
.span(statement.span.clone()),
@ -289,7 +289,7 @@ impl<'ast> From<pest::IterationStatement<'ast>> for absy::StatementNode<'ast> {
let statements: Vec<absy::StatementNode<'ast>> = statement
.statements
.into_iter()
.flat_map(|s| statements_from_statement(s))
.flat_map(statements_from_statement)
.collect();
let var = absy::Variable::new(index, ty).span(statement.index.span);
@ -472,7 +472,7 @@ impl<'ast> From<pest::InlineArrayExpression<'ast>> for absy::ExpressionNode<'ast
array
.expressions
.into_iter()
.map(|e| absy::SpreadOrExpression::from(e))
.map(absy::SpreadOrExpression::from)
.collect(),
)
.span(array.span)
@ -538,7 +538,7 @@ impl<'ast> From<pest::PostfixExpression<'ast>> for absy::ExpressionNode<'ast> {
&id_str,
a.expressions
.into_iter()
.map(|e| absy::ExpressionNode::from(e))
.map(absy::ExpressionNode::from)
.collect(),
),
e => unimplemented!("only identifiers are callable, found \"{}\"", e),
@ -933,7 +933,7 @@ mod tests {
// we basically accept `()?[]*` : an optional call at first, then only array accesses
let vectors = vec![
("a", absy::Expression::Identifier("a").into()),
("a", absy::Expression::Identifier("a")),
(
"a[3]",
absy::Expression::Select(

8
zokrates_core/src/absy/mod.rs
View file

@ -323,9 +323,9 @@ impl<'ast> fmt::Display for Statement<'ast> {
Statement::Definition(ref lhs, ref rhs) => write!(f, "{} = {}", lhs, rhs),
Statement::Assertion(ref e) => write!(f, "assert({})", e),
Statement::For(ref var, ref start, ref stop, ref list) => {
write!(f, "for {} in {}..{} do\n", var, start, stop)?;
writeln!(f, "for {} in {}..{} do", var, start, stop)?;
for l in list {
write!(f, "\t\t{}\n", l)?;
writeln!(f, "\t\t{}", l)?;
}
write!(f, "\tendfor")
}
@ -352,9 +352,9 @@ impl<'ast> fmt::Debug for Statement<'ast> {
}
Statement::Assertion(ref e) => write!(f, "Assertion({:?})", e),
Statement::For(ref var, ref start, ref stop, ref list) => {
write!(f, "for {:?} in {:?}..{:?} do\n", var, start, stop)?;
writeln!(f, "for {:?} in {:?}..{:?} do", var, start, stop)?;
for l in list {
write!(f, "\t\t{:?}\n", l)?;
writeln!(f, "\t\t{:?}", l)?;
}
write!(f, "\tendfor")
}

9
zokrates_core/src/compile.rs
View file

@ -198,12 +198,11 @@ fn check_with_arena<'ast, T: Field, E: Into<imports::Error>>(
arena: &'ast Arena<String>,
) -> Result<(ZirProgram<'ast, T>, Abi), CompileErrors> {
let source = arena.alloc(source);
let compiled = compile_program::<T, E>(source, location.clone(), resolver, &arena)?;
let compiled = compile_program::<T, E>(source, location, resolver, &arena)?;
// check semantics
let typed_ast = Checker::check(compiled).map_err(|errors| {
CompileErrors(errors.into_iter().map(|e| CompileError::from(e)).collect())
})?;
let typed_ast = Checker::check(compiled)
.map_err(|errors| CompileErrors(errors.into_iter().map(CompileError::from).collect()))?;
let main_module = typed_ast.main.clone();
@ -246,7 +245,7 @@ pub fn compile_module<'ast, T: Field, E: Into<imports::Error>>(
let module_without_imports: Module = Module::from(ast);
Importer::new().apply_imports::<T, E>(
Importer::apply_imports::<T, E>(
module_without_imports,
location.clone(),
resolver,

8
zokrates_core/src/embed.rs
View file

@ -88,7 +88,7 @@ fn use_variable(
) -> FlatVariable {
let var = FlatVariable::new(*index);
layout.insert(name, var);
*index = *index + 1;
*index += 1;
var
}
@ -119,7 +119,7 @@ pub fn unpack_to_bitwidth<T: Field>(bit_width: usize) -> FlatFunction<T> {
let directive_inputs = vec![FlatExpression::Identifier(use_variable(
&mut layout,
format!("i0"),
"i0".into(),
&mut counter,
))];
@ -132,7 +132,7 @@ pub fn unpack_to_bitwidth<T: Field>(bit_width: usize) -> FlatFunction<T> {
let outputs = directive_outputs
.iter()
.enumerate()
.map(|(_, o)| FlatExpression::Identifier(o.clone()))
.map(|(_, o)| FlatExpression::Identifier(*o))
.collect::<Vec<_>>();
// o253, o252, ... o{253 - (bit_width - 1)} are bits
@ -172,7 +172,7 @@ pub fn unpack_to_bitwidth<T: Field>(bit_width: usize) -> FlatFunction<T> {
FlatStatement::Directive(FlatDirective {
inputs: directive_inputs,
outputs: directive_outputs,
solver: solver,
solver,
}),
);

2
zokrates_core/src/flat_absy/flat_parameter.rs
View file

@ -41,7 +41,7 @@ impl FlatParameter {
substitution: &HashMap<FlatVariable, FlatVariable>,
) -> FlatParameter {
FlatParameter {
id: substitution.get(&self.id).unwrap().clone(),
id: *substitution.get(&self.id).unwrap(),
private: self.private,
}
}

2
zokrates_core/src/flat_absy/flat_variable.rs
View file

@ -45,7 +45,7 @@ impl FlatVariable {
Ok(FlatVariable::public(v))
}
None => {
let mut private = s.split("_");
let mut private = s.split('_');
match private.nth(1) {
Some(v) => {
let v = v.parse().map_err(|_| s)?;

156
zokrates_core/src/flatten/mod.rs
View file

@ -170,7 +170,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
statements_flattened: &mut FlatStatements<T>,
) -> FlatVariable {
match e {
FlatExpression::Identifier(id) => id.into(),
FlatExpression::Identifier(id) => id,
e => {
let res = self.use_sym();
statements_flattened.push(FlatStatement::Definition(res, e));
@ -249,10 +249,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// sizeUnknown is not changing in this case
// We sill have to assign the old value to the variable of the current run
// This trivial definition will later be removed by the optimiser
FlatStatement::Definition(
size_unknown[i + 1].into(),
size_unknown[i].into(),
),
FlatStatement::Definition(size_unknown[i + 1], size_unknown[i].into()),
);
}
@ -375,7 +372,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// those will be booleans in the future
match expression {
BooleanExpression::Identifier(x) => {
FlatExpression::Identifier(self.layout.get(&x).unwrap().clone())
FlatExpression::Identifier(*self.layout.get(&x).unwrap())
}
BooleanExpression::FieldLt(box lhs, box rhs) => {
// Get the bit width to know the size of the binary decompositions for this Field
@ -409,12 +406,12 @@ impl<'ast, T: Field> Flattener<'ast, T> {
)));
// bitness checks
for i in 0..safe_width {
for bit in lhs_bits_be.iter().take(safe_width) {
statements_flattened.push(FlatStatement::Condition(
FlatExpression::Identifier(lhs_bits_be[i]),
FlatExpression::Identifier(*bit),
FlatExpression::Mult(
box FlatExpression::Identifier(lhs_bits_be[i]),
box FlatExpression::Identifier(lhs_bits_be[i]),
box FlatExpression::Identifier(*bit),
box FlatExpression::Identifier(*bit),
),
));
}
@ -422,11 +419,11 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// bit decomposition check
let mut lhs_sum = FlatExpression::Number(T::from(0));
for i in 0..safe_width {
for (i, bit) in lhs_bits_be.iter().enumerate().take(safe_width) {
lhs_sum = FlatExpression::Add(
box lhs_sum,
box FlatExpression::Mult(
box FlatExpression::Identifier(lhs_bits_be[i]),
box FlatExpression::Identifier(*bit),
box FlatExpression::Number(T::from(2).pow(safe_width - i - 1)),
),
);
@ -455,12 +452,12 @@ impl<'ast, T: Field> Flattener<'ast, T> {
)));
// bitness checks
for i in 0..safe_width {
for bit in rhs_bits_be.iter().take(safe_width) {
statements_flattened.push(FlatStatement::Condition(
FlatExpression::Identifier(rhs_bits_be[i]),
FlatExpression::Identifier(*bit),
FlatExpression::Mult(
box FlatExpression::Identifier(rhs_bits_be[i]),
box FlatExpression::Identifier(rhs_bits_be[i]),
box FlatExpression::Identifier(*bit),
box FlatExpression::Identifier(*bit),
),
));
}
@ -468,11 +465,11 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// bit decomposition check
let mut rhs_sum = FlatExpression::Number(T::from(0));
for i in 0..safe_width {
for (i, bit) in rhs_bits_be.iter().enumerate().take(safe_width) {
rhs_sum = FlatExpression::Add(
box rhs_sum,
box FlatExpression::Mult(
box FlatExpression::Identifier(rhs_bits_be[i]),
box FlatExpression::Identifier(*bit),
box FlatExpression::Number(T::from(2).pow(safe_width - i - 1)),
),
);
@ -508,12 +505,12 @@ impl<'ast, T: Field> Flattener<'ast, T> {
)));
// bitness checks
for i in 0..bit_width {
for bit in sub_bits_be.iter().take(bit_width) {
statements_flattened.push(FlatStatement::Condition(
FlatExpression::Identifier(sub_bits_be[i]),
FlatExpression::Identifier(*bit),
FlatExpression::Mult(
box FlatExpression::Identifier(sub_bits_be[i]),
box FlatExpression::Identifier(sub_bits_be[i]),
box FlatExpression::Identifier(*bit),
box FlatExpression::Identifier(*bit),
),
));
}
@ -528,11 +525,11 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// sum(sym_b{i} * 2**i)
let mut expr = FlatExpression::Number(T::from(0));
for i in 0..bit_width {
for (i, bit) in sub_bits_be.iter().enumerate().take(bit_width) {
expr = FlatExpression::Add(
box expr,
box FlatExpression::Mult(
box FlatExpression::Identifier(sub_bits_be[i]),
box FlatExpression::Identifier(*bit),
box FlatExpression::Number(T::from(2).pow(bit_width - i - 1)),
),
);
@ -826,8 +823,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
consequence,
alternative,
)
.get_field_unchecked()
.clone(),
.get_field_unchecked(),
}
}
@ -841,12 +837,10 @@ impl<'ast, T: Field> Flattener<'ast, T> {
let expression = UExpression::try_from(expression).unwrap();
let from = expression.metadata.clone().unwrap().bitwidth();
let p = self.flatten_uint_expression(symbols, statements_flattened, expression);
let bits = self
.get_bits(p, from as usize, bitwidth, statements_flattened)
self.get_bits(p, from as usize, bitwidth, statements_flattened)
.into_iter()
.map(|b| FlatUExpression::with_field(b))
.collect();
bits
.map(FlatUExpression::with_field)
.collect()
}
fn flatten_bits_to_u(
@ -956,11 +950,10 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// Ensure renaming and correct returns:
// add all flattened statements, adapt return statements
let (mut return_statements, statements): (Vec<_>, Vec<_>) =
funct.statements.into_iter().partition(|s| match s {
FlatStatement::Return(..) => true,
_ => false,
});
let (mut return_statements, statements): (Vec<_>, Vec<_>) = funct
.statements
.into_iter()
.partition(|s| matches!(s, FlatStatement::Return(..)));
let statements: Vec<_> = statements
.into_iter()
@ -1009,7 +1002,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
.expressions
.into_iter()
.map(|x| x.apply_substitution(&replacement_map))
.map(|x| FlatUExpression::with_field(x))
.map(FlatUExpression::with_field)
.collect(),
_ => unreachable!(),
}
@ -1083,7 +1076,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
statements_flattened.extend(vec![
FlatStatement::Directive(FlatDirective::new(
vec![name.clone()],
vec![name],
Solver::Xor,
vec![x.clone(), y.clone()],
)),
@ -1149,7 +1142,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// assert(invd * d == 1)
statements_flattened.push(FlatStatement::Condition(
FlatExpression::Number(T::one()),
FlatExpression::Mult(box invd.into(), box d.clone().into()),
FlatExpression::Mult(box invd.into(), box d.clone()),
));
// now introduce the quotient and remainder
@ -1158,7 +1151,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
statements_flattened.push(FlatStatement::Directive(FlatDirective {
inputs: vec![n.clone(), d.clone()],
outputs: vec![q.clone(), r.clone()],
outputs: vec![q, r],
solver: Solver::EuclideanDiv,
}));
@ -1181,7 +1174,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// r < d <=> r - d + 2**w < 2**w
let _ = self.get_bits(
FlatUExpression::with_field(FlatExpression::Add(
box FlatExpression::Sub(box r.into(), box d.clone().into()),
box FlatExpression::Sub(box r.into(), box d.clone()),
box FlatExpression::Number(T::from(2usize.pow(target_bitwidth.to_usize() as u32))),
)),
target_bitwidth.to_usize(),
@ -1214,7 +1207,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// the bitwidth for this type of uint (8, 16 or 32)
let target_bitwidth = expr.bitwidth;
let metadata = expr.metadata.clone().unwrap().clone();
let metadata = expr.metadata.clone().unwrap();
// the bitwidth on which this value is currently represented
let actual_bitwidth = metadata.bitwidth() as usize;
@ -1229,7 +1222,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
FlatUExpression::with_field(FlatExpression::Number(T::from(x as usize)))
} // force to be a field element
UExpressionInner::Identifier(x) => {
let field = FlatExpression::Identifier(self.layout.get(&x).unwrap().clone());
let field = FlatExpression::Identifier(*self.layout.get(&x).unwrap());
let bits = self.bits_cache.get(&field).map(|bits| {
assert_eq!(bits.len(), target_bitwidth.to_usize());
bits.clone()
@ -1423,8 +1416,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
condition,
consequence,
alternative,
)
.clone(),
),
UExpressionInner::Xor(box left, box right) => {
let left_metadata = left.metadata.clone().unwrap();
let right_metadata = right.metadata.clone().unwrap();
@ -1454,7 +1446,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
statements_flattened.extend(vec![
FlatStatement::Directive(FlatDirective::new(
vec![ch.clone()],
vec![ch],
Solver::ShaCh,
vec![a.clone(), b.clone(), c.clone()],
)),
@ -1528,7 +1520,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
statements_flattened.extend(vec![
FlatStatement::Directive(FlatDirective::new(
vec![maj.clone()],
vec![maj],
Solver::ShaAndXorAndXorAnd,
vec![a.clone(), b.clone(), c.clone()],
)),
@ -1672,7 +1664,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
statements_flattened.extend(vec![
FlatStatement::Directive(FlatDirective::new(
vec![name.clone()],
vec![name],
Solver::Or,
vec![x.clone(), y.clone()],
)),
@ -1715,7 +1707,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
box FlatExpression::Number(
T::from(2).pow(target_bitwidth.to_usize() - index - 1),
),
box bit.clone().into(),
box bit.clone(),
),
)
},
@ -1745,22 +1737,19 @@ impl<'ast, T: Field> Flattener<'ast, T> {
assert!(to < T::get_required_bits());
// constants do not require directives
match e.field {
Some(FlatExpression::Number(ref x)) => {
let bits: Vec<_> = ir::Interpreter::default()
.execute_solver(&Solver::bits(to), &vec![x.clone()])
.unwrap()
.into_iter()
.map(|x| FlatExpression::Number(x))
.collect();
if let Some(FlatExpression::Number(ref x)) = e.field {
let bits: Vec<_> = ir::Interpreter::default()
.execute_solver(&Solver::bits(to), &vec![x.clone()])
.unwrap()
.into_iter()
.map(FlatExpression::Number)
.collect();
assert_eq!(bits.len(), to);
assert_eq!(bits.len(), to);
self.bits_cache
.insert(e.field.clone().unwrap(), bits.clone());
return bits;
}
_ => {}
self.bits_cache
.insert(e.field.clone().unwrap(), bits.clone());
return bits;
};
e.bits.clone().unwrap_or_else(|| {
@ -1771,7 +1760,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
let from = std::cmp::max(from, to);
match self.bits_cache.entry(e.field.clone().unwrap()) {
Entry::Occupied(entry) => {
let res: Vec<_> = entry.get().clone().into_iter().map(|e| e.into()).collect();
let res: Vec<_> = entry.get().clone();
// if we already know a decomposition, it has to be of the size of the target bitwidth
assert_eq!(res.len(), to);
res
@ -1784,21 +1773,15 @@ impl<'ast, T: Field> Flattener<'ast, T> {
vec![e.field.clone().unwrap()],
)));
let bits: Vec<_> = bits
.into_iter()
.map(|b| FlatExpression::Identifier(b))
.collect();
let bits: Vec<_> = bits.into_iter().map(FlatExpression::Identifier).collect();
// decompose to the actual bitwidth
// bit checks
statements_flattened.extend((0..from).map(|i| {
statements_flattened.extend(bits.iter().take(from).map(|bit| {
FlatStatement::Condition(
bits[i].clone(),
FlatExpression::Mult(
box bits[i].clone().into(),
box bits[i].clone().into(),
),
bit.clone(),
FlatExpression::Mult(box bit.clone(), box bit.clone()),
)
}));
@ -1818,7 +1801,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
self.bits_cache.insert(e.field.unwrap(), bits.clone());
self.bits_cache.insert(sum, bits.clone());
bits.into_iter().map(|v| v.into()).collect()
bits
}
}
})
@ -1936,7 +1919,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// assert(invb * b == 1)
statements_flattened.push(FlatStatement::Condition(
FlatExpression::Number(T::one()),
FlatExpression::Mult(box invb.into(), box new_right.clone().into()),
FlatExpression::Mult(box invb.into(), box new_right.clone()),
));
// # c = a/b
@ -1948,7 +1931,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
// assert(c * b == a)
statements_flattened.push(FlatStatement::Condition(
new_left.into(),
new_left,
FlatExpression::Mult(box new_right, box inverse.into()),
));
@ -1996,16 +1979,16 @@ impl<'ast, T: Field> Flattener<'ast, T> {
let id = self.use_sym();
// set it to the square of the previous one, stored in state
statements_flattened.push(FlatStatement::Definition(
id.clone(),
id,
FlatExpression::Mult(
box previous.clone(),
box previous.clone(),
),
));
// store it in the state for later squaring
*state = Some(FlatExpression::Identifier(id.clone()));
*state = Some(FlatExpression::Identifier(id));
// return it for later use constructing the result
Some(FlatExpression::Identifier(id.clone()))
Some(FlatExpression::Identifier(id))
}
}
})
@ -2039,8 +2022,7 @@ impl<'ast, T: Field> Flattener<'ast, T> {
consequence,
alternative,
)
.get_field_unchecked()
.clone(),
.get_field_unchecked(),
}
}
@ -2071,7 +2053,6 @@ impl<'ast, T: Field> Flattener<'ast, T> {
}
ZirStatement::Declaration(_) => {
// declarations have already been checked
()
}
ZirStatement::Definition(assignee, expr) => {
// define n variables with n the number of primitive types for v_type
@ -2097,12 +2078,9 @@ impl<'ast, T: Field> Flattener<'ast, T> {
};
// register bits
match bits {
Some(bits) => {
self.bits_cache
.insert(FlatExpression::Identifier(var), bits);
}
None => {}
if let Some(bits) = bits {
self.bits_cache
.insert(FlatExpression::Identifier(var), bits);
}
}
ZirStatement::Assertion(e) => {

26
zokrates_core/src/imports.rs
View file

@ -42,7 +42,7 @@ impl fmt::Display for Error {
let location = self
.pos
.map(|p| format!("{}", p.0))
.unwrap_or("?".to_string());
.unwrap_or_else(|| "?".to_string());
write!(f, "{}\n\t{}", location, self.message)
}
}
@ -125,15 +125,10 @@ impl<'ast> fmt::Debug for Import<'ast> {
}
}
pub struct Importer {}
pub struct Importer;
impl Importer {
pub fn new() -> Importer {
Importer {}
}
pub fn apply_imports<'ast, T: Field, E: Into<Error>>(
&self,
destination: Module<'ast>,
location: PathBuf,
resolver: Option<&dyn Resolver<E>>,
@ -243,13 +238,15 @@ impl Importer {
let alias = import.alias.unwrap_or(
std::path::Path::new(import.source)
.file_stem()
.ok_or(CompileErrors::from(
CompileErrorInner::ImportError(Error::new(format!(
"Could not determine alias for import {}",
import.source.display()
)))
.in_file(&location),
))?
.ok_or_else(|| {
CompileErrors::from(
CompileErrorInner::ImportError(Error::new(format!(
"Could not determine alias for import {}",
import.source.display()
)))
.in_file(&location),
)
})?
.to_str()
.unwrap(),
);
@ -311,7 +308,6 @@ impl Importer {
Ok(Module {
imports: vec![],
symbols,
..destination
})
}
}

8
zokrates_core/src/ir/expression.rs
View file

@ -113,7 +113,7 @@ impl<T> LinComb<T> {
}
pub fn is_zero(&self) -> bool {
self.0.len() == 0
self.0.is_empty()
}
}
@ -141,7 +141,7 @@ impl<T: Field> LinComb<T> {
// collect to a Result to short circuit when we hit an error
.collect::<Result<_, _>>()
// we didn't hit an error, do final processing. It's fine to clone here.
.map(|v: Vec<_>| (first.clone(), v.iter().fold(T::zero(), |acc, e| acc + *e)))
.map(|v: Vec<_>| (*first, v.iter().fold(T::zero(), |acc, e| acc + *e)))
.ok()
}
}
@ -287,7 +287,7 @@ mod tests {
fn add() {
let a: LinComb<Bn128Field> = FlatVariable::new(42).into();
let b: LinComb<Bn128Field> = FlatVariable::new(42).into();
let c = a + b.clone();
let c = a + b;
let expected_vec = vec![
(FlatVariable::new(42), Bn128Field::from(1)),
@ -300,7 +300,7 @@ mod tests {
fn sub() {
let a: LinComb<Bn128Field> = FlatVariable::new(42).into();
let b: LinComb<Bn128Field> = FlatVariable::new(42).into();
let c = a - b.clone();
let c = a - b;
let expected_vec = vec![
(FlatVariable::new(42), Bn128Field::from(1)),

2
zokrates_core/src/ir/from_flat.rs
View file

@ -125,7 +125,7 @@ impl<T: Field> From<FlatDirective<T>> for Directive<T> {
inputs: ds
.inputs
.into_iter()
.map(|i| QuadComb::from_flat_expression(i))
.map(QuadComb::from_flat_expression)
.collect(),
solver: ds.solver,
outputs: ds.outputs,

26
zokrates_core/src/ir/interpreter.rs
View file

@ -40,7 +40,7 @@ impl Interpreter {
let mut witness = BTreeMap::new();
witness.insert(FlatVariable::one(), T::one());
for (arg, value) in main.arguments.iter().zip(inputs.iter()) {
witness.insert(arg.clone(), value.clone().into());
witness.insert(*arg, value.clone());
}
for statement in main.statements.iter() {
@ -48,7 +48,7 @@ impl Interpreter {
Statement::Constraint(quad, lin) => match lin.is_assignee(&witness) {
true => {
let val = quad.evaluate(&witness).unwrap();
witness.insert(lin.0.iter().next().unwrap().0.clone(), val);
witness.insert(lin.0.get(0).unwrap().0, val);
}
false => {
let lhs_value = quad.evaluate(&witness).unwrap();
@ -79,7 +79,7 @@ impl Interpreter {
match self.execute_solver(&d.solver, &inputs) {
Ok(res) => {
for (i, o) in d.outputs.iter().enumerate() {
witness.insert(o.clone(), res[i].clone());
witness.insert(*o, res[i].clone());
}
continue;
}
@ -107,12 +107,12 @@ impl Interpreter {
value.to_biguint()
};
let mut num = input.clone();
let mut num = input;
let mut res = vec![];
let bits = T::get_required_bits();
for i in (0..bits).rev() {
if T::from(2).to_biguint().pow(i as usize) <= num {
num = num - T::from(2).to_biguint().pow(i as usize);
num -= T::from(2).to_biguint().pow(i as usize);
res.push(T::one());
} else {
res.push(T::zero());
@ -120,7 +120,7 @@ impl Interpreter {
}
assert_eq!(num, T::zero().to_biguint());
for (i, o) in d.outputs.iter().enumerate() {
witness.insert(o.clone(), res[i].clone());
witness.insert(*o, res[i].clone());
}
}
@ -135,11 +135,15 @@ impl Interpreter {
}
}
pub fn execute_solver<T: Field>(&self, s: &Solver, inputs: &Vec<T>) -> Result<Vec<T>, String> {
let (expected_input_count, expected_output_count) = s.get_signature();
pub fn execute_solver<T: Field>(
&self,
solver: &Solver,
inputs: &Vec<T>,
) -> Result<Vec<T>, String> {
let (expected_input_count, expected_output_count) = solver.get_signature();
assert!(inputs.len() == expected_input_count);
let res = match s {
let res = match solver {
Solver::ConditionEq => match inputs[0].is_zero() {
true => vec![T::zero(), T::one()],
false => vec![
@ -220,8 +224,8 @@ impl<T: Field> LinComb<T> {
fn is_assignee<U>(&self, witness: &BTreeMap<FlatVariable, U>) -> bool {
self.0.iter().count() == 1
&& self.0.iter().next().unwrap().1 == T::from(1)
&& !witness.contains_key(&self.0.iter().next().unwrap().0)
&& self.0.get(0).unwrap().1 == T::from(1)
&& !witness.contains_key(&self.0.get(0).unwrap().0)
}
}

6
zokrates_core/src/ir/serialize.rs
View file

@ -16,9 +16,9 @@ pub enum ProgEnum {
impl<T: Field> Prog<T> {
pub fn serialize<W: Write>(&self, mut w: W) {
w.write(ZOKRATES_MAGIC).unwrap();
w.write(ZOKRATES_VERSION_1).unwrap();
w.write(&T::id()).unwrap();
w.write_all(ZOKRATES_MAGIC).unwrap();
w.write_all(ZOKRATES_VERSION_1).unwrap();
w.write_all(&T::id()).unwrap();
serialize_into(&mut w, self, Infinite).unwrap();
}

2
zokrates_core/src/macros.rs
View file

@ -19,7 +19,7 @@ impl fmt::Display for Error {
}
}
pub fn process_macros<'ast, T: Field>(file: File<'ast>) -> Result<File<'ast>, Error> {
pub fn process_macros<T: Field>(file: File) -> Result<File, Error> {
match &file.pragma {
Some(pragma) => {
if T::name() != pragma.curve.name {

2
zokrates_core/src/optimizer/directive.rs
View file

@ -49,7 +49,7 @@ impl<T: Field> Folder<T> for DirectiveOptimizer<T> {
}
Entry::Occupied(e) => {
self.substitution
.extend(d.outputs.into_iter().zip(e.get().into_iter().cloned()));
.extend(d.outputs.into_iter().zip(e.get().iter().cloned()));
vec![]
}
}

2
zokrates_core/src/optimizer/duplicate.rs
View file

@ -120,7 +120,7 @@ mod tests {
main: Function {
id: "main".to_string(),
statements: vec![
constraint.clone(),
constraint,
Statement::Constraint(
QuadComb::from_linear_combinations(
LinComb::summand(3, FlatVariable::new(42)),

31
zokrates_core/src/optimizer/redefinition.rs
View file

@ -94,19 +94,13 @@ impl<T: Field> Folder<T> for RedefinitionOptimizer<T> {
};
// insert into the ignored set
match to_ignore {
Some(v) => {
self.ignore.insert(v);
}
None => {}
if let Some(v) = to_ignore {
self.ignore.insert(v);
}
// insert into the substitution map
match to_insert {
Some((k, v)) => {
self.substitution.insert(k, v.into_canonical());
}
None => {}
if let Some((k, v)) = to_insert {
self.substitution.insert(k, v.into_canonical());
};
// decide whether the constraint should be kept
@ -136,7 +130,7 @@ impl<T: Field> Folder<T> for RedefinitionOptimizer<T> {
v if v == FlatVariable::one() => Ok(coefficient),
_ => Err(LinComb::summand(coefficient, variable).into()),
})
.unwrap_or(Err(l.into())),
.unwrap_or_else(|| Err(l.into())),
},
None => Err(q),
})
@ -184,8 +178,7 @@ impl<T: Field> Folder<T> for RedefinitionOptimizer<T> {
match lc
.0
.iter()
.find(|(variable, _)| self.substitution.get(&variable).is_some())
.is_some()
.any(|(variable, _)| self.substitution.get(&variable).is_some())
{
true =>
// for each summand, check if it is equal to a linear term in our substitution, otherwise keep it as is
@ -195,7 +188,7 @@ impl<T: Field> Folder<T> for RedefinitionOptimizer<T> {
self.substitution
.get(&variable)
.map(|l| LinComb::from(l.clone()) * &coefficient)
.unwrap_or(LinComb::summand(coefficient, variable))
.unwrap_or_else(|| LinComb::summand(coefficient, variable))
})
.fold(LinComb::zero(), |acc, x| acc + x)
}
@ -243,7 +236,7 @@ mod tests {
id: "foo".to_string(),
arguments: vec![x],
statements: vec![Statement::definition(y, x), Statement::definition(z, y)],
returns: vec![z.into()],
returns: vec![z],
};
let optimized: Function<Bn128Field> = Function {
@ -270,7 +263,7 @@ mod tests {
id: "foo".to_string(),
arguments: vec![x],
statements: vec![Statement::definition(one, x)],
returns: vec![x.into()],
returns: vec![x],
};
let optimized = f.clone();
@ -305,14 +298,14 @@ mod tests {
Statement::definition(z, y),
Statement::constraint(z, y),
],
returns: vec![z.into()],
returns: vec![z],
};
let optimized: Function<Bn128Field> = Function {
id: "foo".to_string(),
arguments: vec![x],
statements: vec![Statement::definition(z, x), Statement::constraint(z, x)],
returns: vec![z.into()],
returns: vec![z],
};
let mut optimizer = RedefinitionOptimizer::new();
@ -482,7 +475,7 @@ mod tests {
Statement::constraint(x, Bn128Field::from(1)),
Statement::constraint(x, Bn128Field::from(2)),
],
returns: vec![x.into()],
returns: vec![x],
};
let optimized = f.clone();

9
zokrates_core/src/optimizer/tautology.rs
View file

@ -26,13 +26,10 @@ impl<T: Field> Folder<T> for TautologyOptimizer {
fn fold_statement(&mut self, s: Statement<T>) -> Vec<Statement<T>> {
match s {
Statement::Constraint(quad, lin) => {
match quad.try_linear() {
Some(l) => {
if l == lin {
return vec![];
}
if let Some(l) = quad.try_linear() {
if l == lin {
return vec![];
}
None => {}
}
vec![Statement::Constraint(quad, lin)]
}

4
zokrates_core/src/proof_system/ark/gm17.rs
View file

@ -78,7 +78,7 @@ impl<T: Field + ArkFieldExtensions + NotBw6_761Field> Backend<T, GM17> for Ark {
query: vk
.query
.into_iter()
.map(|g1| serialization::to_g1::<T>(g1))
.map(serialization::to_g1::<T>)
.collect(),
};
@ -172,7 +172,7 @@ impl Backend<Bw6_761Field, GM17> for Ark {
query: vk
.query
.into_iter()
.map(|g1| serialization::to_g1::<Bw6_761Field>(g1))
.map(serialization::to_g1::<Bw6_761Field>)
.collect(),
};

43
zokrates_core/src/proof_system/ark/mod.rs
View file

@ -58,28 +58,25 @@ fn ark_combination<T: Field + ArkFieldExtensions>(
.map(|(k, v)| {
(
v.into_ark(),
symbols
.entry(k)
.or_insert_with(|| {
match k.is_output() {
true => cs.new_input_variable(|| {
Ok(witness
.0
.remove(&k)
.ok_or(SynthesisError::AssignmentMissing)?
.into_ark())
}),
false => cs.new_witness_variable(|| {
Ok(witness
.0
.remove(&k)
.ok_or(SynthesisError::AssignmentMissing)?
.into_ark())
}),
}
.unwrap()
})
.clone(),
*symbols.entry(k).or_insert_with(|| {
match k.is_output() {
true => cs.new_input_variable(|| {
Ok(witness
.0
.remove(&k)
.ok_or(SynthesisError::AssignmentMissing)?
.into_ark())
}),
false => cs.new_witness_variable(|| {
Ok(witness
.0
.remove(&k)
.ok_or(SynthesisError::AssignmentMissing)?
.into_ark())
}),
}
.unwrap()
}),
)
})
.fold(LinearCombination::zero(), |acc, e| acc + e);
@ -127,7 +124,7 @@ impl<T: Field + ArkFieldExtensions> Prog<T> {
}),
}
.unwrap();
(var.clone(), wire)
(*var, wire)
}),
);

2
zokrates_core/src/proof_system/bellman/groth16.rs
View file

@ -81,7 +81,7 @@ impl<T: Field + BellmanFieldExtensions> Backend<T, G16> for Bellman {
ic: vk
.gamma_abc
.into_iter()
.map(|g1| serialization::to_g1::<T>(g1))
.map(serialization::to_g1::<T>)
.collect(),
};

55
zokrates_core/src/proof_system/bellman/mod.rs
View file

@ -51,34 +51,31 @@ fn bellman_combination<T: BellmanFieldExtensions, CS: ConstraintSystem<T::Bellma
.map(|(k, v)| {
(
v.into_bellman(),
symbols
.entry(k)
.or_insert_with(|| {
match k.is_output() {
true => cs.alloc_input(
|| format!("{}", k),
|| {
Ok(witness
.0
.remove(&k)
.ok_or(SynthesisError::AssignmentMissing)?
.into_bellman())
},
),
false => cs.alloc(
|| format!("{}", k),
|| {
Ok(witness
.0
.remove(&k)
.ok_or(SynthesisError::AssignmentMissing)?
.into_bellman())
},
),
}
.unwrap()
})
.clone(),
*symbols.entry(k).or_insert_with(|| {
match k.is_output() {
true => cs.alloc_input(
|| format!("{}", k),
|| {
Ok(witness
.0
.remove(&k)
.ok_or(SynthesisError::AssignmentMissing)?
.into_bellman())
},
),
false => cs.alloc(
|| format!("{}", k),
|| {
Ok(witness
.0
.remove(&k)
.ok_or(SynthesisError::AssignmentMissing)?
.into_bellman())
},
),
}
.unwrap()
}),
)
})
.fold(LinearCombination::zero(), |acc, e| acc + e)
@ -127,7 +124,7 @@ impl<T: BellmanFieldExtensions + Field> Prog<T> {
),
}
.unwrap();
(var.clone(), wire)
(*var, wire)
}),
);

102
zokrates_core/src/semantics.rs
View file

@ -127,7 +127,7 @@ impl fmt::Display for ErrorInner {
let location = self
.pos
.map(|p| format!("{}", p.0))
.unwrap_or("?".to_string());
.unwrap_or_else(|| "?".to_string());
write!(f, "{}\n\t{}", location, self.message)
}
}
@ -159,7 +159,7 @@ impl<'ast, T: fmt::Display> fmt::Display for FunctionQuery<'ast, T> {
" -> {}",
match &self.outputs[0] {
Some(t) => format!("{}", t),
None => format!("_"),
None => "_".into(),
}
),
_ => {
@ -183,13 +183,13 @@ impl<'ast, T: Field> FunctionQuery<'ast, T> {
/// Create a new query.
fn new(
id: Identifier<'ast>,
inputs: &Vec<Type<'ast, T>>,
outputs: &Vec<Option<Type<'ast, T>>>,
inputs: &[Type<'ast, T>],
outputs: &[Option<Type<'ast, T>>],
) -> Self {
FunctionQuery {
id,
inputs: inputs.clone(),
outputs: outputs.clone(),
inputs: inputs.to_owned(),
outputs: outputs.to_owned(),
}
}
@ -289,7 +289,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
Err(e) => errors.extend(e),
};
if errors.len() > 0 {
if !errors.is_empty() {
return Err(errors);
}
@ -343,7 +343,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
}
}
if errors.len() > 0 {
if !errors.is_empty() {
return Err(errors);
}
@ -506,7 +506,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
.types
.entry(module_id.clone())
.or_default()
.insert(declaration.id.to_string(), t.clone());
.insert(declaration.id.to_string(), t);
}
(0, None) => {
errors.push(ErrorInner {
@ -589,7 +589,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
};
// return if any errors occured
if errors.len() > 0 {
if !errors.is_empty() {
return Err(errors);
}
@ -635,15 +635,12 @@ impl<'ast, T: Field> Checker<'ast, T> {
};
// insert into typed_modules if we checked anything
match to_insert {
Some(typed_module) => {
// there should be no checked module at that key just yet, if there is we have a colision or we checked something twice
assert!(state
.typed_modules
.insert(module_id.clone(), typed_module)
.is_none());
}
None => {}
if let Some(typed_module) = to_insert {
// there should be no checked module at that key just yet, if there is we have a colision or we checked something twice
assert!(state
.typed_modules
.insert(module_id.clone(), typed_module)
.is_none());
};
Ok(())
@ -659,7 +656,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
1 => Ok(()),
0 => Err(ErrorInner {
pos: None,
message: format!("No main function found"),
message: "No main function found".into(),
}),
n => Err(ErrorInner {
pos: None,
@ -857,7 +854,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
}
}
if errors.len() > 0 {
if !errors.is_empty() {
return Err(errors);
}
@ -1254,10 +1251,9 @@ impl<'ast, T: Field> Checker<'ast, T> {
Statement::Definition(assignee, expr) => {
// we create multidef when rhs is a function call to benefit from inference
// check rhs is not a function call here
match expr.value {
Expression::FunctionCall(..) => panic!("Parser should not generate Definition where the right hand side is a FunctionCall"),
_ => {}
}
if let Expression::FunctionCall(..) = expr.value {
panic!("Parser should not generate Definition where the right hand side is a FunctionCall")
}
// check the expression to be assigned
let checked_expr = self
@ -1338,13 +1334,13 @@ impl<'ast, T: Field> Checker<'ast, T> {
// check lhs assignees are defined
let (assignees, errors): (Vec<_>, Vec<_>) = assignees.into_iter().map(|a| self.check_assignee(a, module_id, types)).partition(|r| r.is_ok());
if errors.len() > 0 {
if !errors.is_empty() {
return Err(errors.into_iter().map(|e| e.unwrap_err()).collect());
}
let assignees: Vec<_> = assignees.into_iter().map(|a| a.unwrap()).collect();
let assignee_types = assignees.iter().map(|a| Some(a.get_type().clone())).collect();
let assignee_types: Vec<_> = assignees.iter().map(|a| Some(a.get_type().clone())).collect();
// find argument types
let mut arguments_checked = vec![];
@ -1353,7 +1349,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
arguments_checked.push(arg_checked);
}
let arguments_types =
let arguments_types: Vec<_> =
arguments_checked.iter().map(|a| a.get_type()).collect();
let query = FunctionQuery::new(&fun_id, &arguments_types, &assignee_types);
@ -1642,7 +1638,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
}
(TypedExpression::Uint(e1), TypedExpression::Uint(e2)) => {
if e1.get_type() == e2.get_type() {
Ok(UExpression::add(e1, e2).into())
Ok((e1 + e2).into())
} else {
Err(ErrorInner {
pos: Some(pos),
@ -1684,7 +1680,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
(Int(e1), Int(e2)) => Ok(IntExpression::Sub(box e1, box e2).into()),
(TypedExpression::Uint(e1), TypedExpression::Uint(e2)) => {
if e1.get_type() == e2.get_type() {
Ok(UExpression::sub(e1, e2).into())
Ok((e1 - e2).into())
} else {
Err(ErrorInner {
pos: Some(pos),
@ -1732,7 +1728,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
}
(TypedExpression::Uint(e1), TypedExpression::Uint(e2)) => {
if e1.get_type() == e2.get_type() {
Ok(UExpression::mult(e1, e2).into())
Ok((e1 * e2).into())
} else {
Err(ErrorInner {
pos: Some(pos),
@ -1787,7 +1783,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
}
(TypedExpression::Uint(e1), TypedExpression::Uint(e2)) => {
if e1.get_type() == e2.get_type() {
Ok(UExpression::div(e1, e2).into())
Ok((e1 / e2).into())
} else {
Err(ErrorInner {
pos: Some(pos),
@ -1818,7 +1814,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
match (e1_checked, e2_checked) {
(TypedExpression::Uint(e1), TypedExpression::Uint(e2)) => {
if e1.get_type() == e2.get_type() {
Ok(UExpression::rem(e1, e2).into())
Ok((e1 % e2).into())
} else {
Err(ErrorInner {
pos: Some(pos),
@ -1954,7 +1950,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
// outside of multidef, function calls must have a single return value
// we use type inference to determine the type of the return, so we don't specify it
let query = FunctionQuery::new(&fun_id, &arguments_types, &vec![None]);
let query = FunctionQuery::new(&fun_id, &arguments_types, &[None]);
let functions = self.find_functions(&query);
@ -3167,7 +3163,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
match e_checked {
TypedExpression::Int(e) => Ok(IntExpression::Not(box e).into()),
TypedExpression::Boolean(e) => Ok(BooleanExpression::Not(box e).into()),
TypedExpression::Uint(e) => Ok(UExpression::not(e).into()),
TypedExpression::Uint(e) => Ok((!e).into()),
e => Err(ErrorInner {
pos: Some(pos),
message: format!("Cannot negate {}", e.get_type()),
@ -3243,7 +3239,7 @@ mod tests {
let module_id = "".into();
let value = Bn128Field::max_value().to_biguint().add(1u32);
let expr = Expression::FieldConstant(BigUint::from(value)).mock();
let expr = Expression::FieldConstant(value).mock();
assert!(Checker::<Bn128Field>::new()
.check_expression(expr, &module_id, &types)
@ -3367,7 +3363,7 @@ mod tests {
fn struct1() -> StructDefinitionNode<'static> {
StructDefinition {
fields: vec![StructDefinitionField {
id: "foo".into(),
id: "foo",
ty: UnresolvedType::FieldElement.mock(),
}
.mock()],
@ -3564,7 +3560,7 @@ mod tests {
let mut checker: Checker<Bn128Field> = Checker::new();
assert_eq!(
checker
.check_module(&PathBuf::from(MODULE_ID).into(), &mut state)
.check_module(&PathBuf::from(MODULE_ID), &mut state)
.unwrap_err()[0]
.inner
.message,
@ -4716,7 +4712,7 @@ mod tests {
)
.mock(),
Statement::Definition(
Assignee::Identifier("a".into()).mock(),
Assignee::Identifier("a").mock(),
Expression::InlineArray(vec![absy::SpreadOrExpression::Expression(
Expression::IntConstant(0usize.into()).mock(),
)])
@ -5511,7 +5507,7 @@ mod tests {
assert_eq!(
checker.check_type(
UnresolvedType::User("Foo".into()).mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
),
Ok(Type::Struct(StructType::new(
@ -5525,7 +5521,7 @@ mod tests {
checker
.check_type(
UnresolvedType::User("Bar".into()).mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
)
.unwrap_err()
@ -5557,7 +5553,7 @@ mod tests {
private: true,
}
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types,
&mut vec![]
),
@ -5589,7 +5585,7 @@ mod tests {
private: true,
}
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types,
&mut vec![]
)
@ -5620,7 +5616,7 @@ mod tests {
.mock()
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types,
),
Ok(TypedStatement::Declaration(Variable::with_id_and_type(
@ -5645,7 +5641,7 @@ mod tests {
private: true,
}
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types,
&mut vec![]
)
@ -5686,7 +5682,7 @@ mod tests {
"foo".into()
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
),
Ok(FieldElementExpression::Member(
@ -5732,7 +5728,7 @@ mod tests {
"bar".into()
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
)
.unwrap_err()
@ -5766,7 +5762,7 @@ mod tests {
vec![("foo", Expression::IntConstant(42usize.into()).mock())]
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
)
.unwrap_err()
@ -5807,7 +5803,7 @@ mod tests {
]
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
),
Ok(StructExpressionInner::Value(vec![
@ -5858,7 +5854,7 @@ mod tests {
]
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
),
Ok(StructExpressionInner::Value(vec![
@ -5907,7 +5903,7 @@ mod tests {
vec![("foo", Expression::IntConstant(42usize.into()).mock())]
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
)
.unwrap_err()
@ -5954,7 +5950,7 @@ mod tests {
)]
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
).unwrap_err()
.message,
@ -5972,7 +5968,7 @@ mod tests {
]
)
.mock(),
&PathBuf::from(MODULE_ID).into(),
&PathBuf::from(MODULE_ID),
&state.types
)
.unwrap_err()

2
zokrates_core/src/solvers/mod.rs
View file

@ -42,7 +42,7 @@ impl Solver {
}
pub trait Executable<T: Field>: Signed {
fn execute(&self, inputs: &Vec<T>) -> Result<Vec<T>, String>;
fn execute(&self, inputs: &[T]) -> Result<Vec<T>, String>;
}
pub trait Signed {

32
zokrates_core/src/static_analysis/flatten_complex_types.rs
View file

@ -298,9 +298,7 @@ pub fn fold_statement<'ast, T: Field>(
}
typed_absy::TypedStatement::Declaration(v) => {
let v = f.fold_variable(v);
v.into_iter()
.map(|v| zir::ZirStatement::Declaration(v))
.collect()
v.into_iter().map(zir::ZirStatement::Declaration).collect()
}
typed_absy::TypedStatement::Assertion(e) => {
let e = f.fold_boolean_expression(e);
@ -323,15 +321,15 @@ pub fn fold_statement<'ast, T: Field>(
pub fn fold_array_expression_inner<'ast, T: Field>(
f: &mut Flattener<T>,
t: &typed_absy::types::ConcreteType,
ty: &typed_absy::types::ConcreteType,
size: usize,
e: typed_absy::ArrayExpressionInner<'ast, T>,
array: typed_absy::ArrayExpressionInner<'ast, T>,
) -> Vec<zir::ZirExpression<'ast, T>> {
match e {
match array {
typed_absy::ArrayExpressionInner::Identifier(id) => {
let variables = flatten_identifier_rec(
f.fold_name(id),
&typed_absy::types::ConcreteType::array(t.clone(), size),
&typed_absy::types::ConcreteType::array(ty.clone(), size),
);
variables
.into_iter()
@ -395,7 +393,7 @@ pub fn fold_array_expression_inner<'ast, T: Field>(
.sum();
// we also need the size of this member
let size = t.get_primitive_count() * size;
let size = ty.get_primitive_count() * size;
s[offset..offset + size].to_vec()
}
@ -405,7 +403,7 @@ pub fn fold_array_expression_inner<'ast, T: Field>(
match index.into_inner() {
zir::UExpressionInner::Value(i) => {
let size = typed_absy::types::ConcreteType::try_from(t.clone())
let size = typed_absy::types::ConcreteType::try_from(ty.clone())
.unwrap()
.get_primitive_count()
* size;
@ -421,14 +419,14 @@ pub fn fold_array_expression_inner<'ast, T: Field>(
pub fn fold_struct_expression_inner<'ast, T: Field>(
f: &mut Flattener<T>,
t: &typed_absy::types::ConcreteStructType,
e: typed_absy::StructExpressionInner<'ast, T>,
ty: &typed_absy::types::ConcreteStructType,
struc: typed_absy::StructExpressionInner<'ast, T>,
) -> Vec<zir::ZirExpression<'ast, T>> {
match e {
match struc {
typed_absy::StructExpressionInner::Identifier(id) => {
let variables = flatten_identifier_rec(
f.fold_name(id),
&typed_absy::types::ConcreteType::struc(t.clone()),
&typed_absy::types::ConcreteType::struc(ty.clone()),
);
variables
.into_iter()
@ -493,7 +491,11 @@ pub fn fold_struct_expression_inner<'ast, T: Field>(
// we also need the size of this member
let size = typed_absy::types::ConcreteType::try_from(
*t.iter().find(|member| member.id == id).cloned().unwrap().ty,
*ty.iter()
.find(|member| member.id == id)
.cloned()
.unwrap()
.ty,
)
.unwrap()
.get_primitive_count();
@ -506,7 +508,7 @@ pub fn fold_struct_expression_inner<'ast, T: Field>(
match index.into_inner() {
zir::UExpressionInner::Value(i) => {
let size = t
let size = ty
.iter()
.map(|m| m.ty.get_primitive_count())
.fold(0, |acc, current| acc + current);

19
zokrates_core/src/static_analysis/propagation.rs
View file

@ -104,10 +104,7 @@ fn is_constant<'ast, T: Field>(e: &TypedExpression<'ast, T>) -> bool {
StructExpressionInner::Value(v) => v.iter().all(|e| is_constant(e)),
_ => false,
},
TypedExpression::Uint(a) => match a.as_inner() {
UExpressionInner::Value(..) => true,
_ => false,
},
TypedExpression::Uint(a) => matches!(a.as_inner(), UExpressionInner::Value(..)),
_ => false,
}
}
@ -302,7 +299,7 @@ impl<'ast, 'a, T: Field> Folder<'ast, T> for Propagator<'ast, 'a, T> {
for i in (0..bitwidth as u32).rev() {
if 2u128.pow(i) <= num {
num = num - 2u128.pow(i);
num -= 2u128.pow(i);
res.push(true);
} else {
res.push(false);
@ -1010,20 +1007,20 @@ impl<'ast, 'a, T: Field> Folder<'ast, T> for Propagator<'ast, 'a, T> {
c => ArrayExpressionInner::IfElse(box c, box consequence, box alternative),
}
}
ArrayExpressionInner::Member(box s, m) => {
let s = self.fold_struct_expression(s);
ArrayExpressionInner::Member(box struc, id) => {
let struc = self.fold_struct_expression(struc);
let members = match s.get_type() {
let members = match struc.get_type() {
Type::Struct(members) => members,
_ => unreachable!("should be a struct"),
};
match s.into_inner() {
match struc.into_inner() {
StructExpressionInner::Value(v) => {
match members
.iter()
.zip(v)
.find(|(member, _)| member.id == m)
.find(|(member, _)| member.id == id)
.unwrap()
.1
{
@ -1031,7 +1028,7 @@ impl<'ast, 'a, T: Field> Folder<'ast, T> for Propagator<'ast, 'a, T> {
_ => unreachable!("should be an array"),
}
}
inner => ArrayExpressionInner::Member(box inner.annotate(members), m),
inner => ArrayExpressionInner::Member(box inner.annotate(members), id),
}
}
e => fold_array_expression_inner(self, ty, size, e),

2
zokrates_core/src/static_analysis/redefinition.rs
View file

@ -68,6 +68,6 @@ impl<'ast, T: Field> Folder<'ast, T> for RedefinitionOptimizer<'ast> {
}
fn fold_name(&mut self, s: Identifier<'ast>) -> Identifier<'ast> {
self.identifiers.get(&s).map(|r| r.clone()).unwrap_or(s)
self.identifiers.get(&s).cloned().unwrap_or(s)
}
}

2
zokrates_core/src/static_analysis/reducer/mod.rs
View file

@ -249,7 +249,7 @@ impl<'ast, 'a, T: Field> Reducer<'ast, 'a, T> {
statement_buffer: vec![],
for_loop_versions_after: vec![],
for_loop_versions,
cache: cache,
cache,
substitutions,
program,
versions,

10
zokrates_core/src/static_analysis/uint_optimizer.rs
View file

@ -24,7 +24,7 @@ impl<'ast, T: Field> UintOptimizer<'ast, T> {
}
}
fn force_reduce<'ast, T: Field>(e: UExpression<'ast, T>) -> UExpression<'ast, T> {
fn force_reduce<T: Field>(e: UExpression<T>) -> UExpression<T> {
let metadata = e.metadata.unwrap();
let should_reduce = metadata.should_reduce.make_true();
@ -38,7 +38,7 @@ fn force_reduce<'ast, T: Field>(e: UExpression<'ast, T>) -> UExpression<'ast, T>
}
}
fn force_no_reduce<'ast, T: Field>(e: UExpression<'ast, T>) -> UExpression<'ast, T> {
fn force_no_reduce<T: Field>(e: UExpression<T>) -> UExpression<T> {
let metadata = e.metadata.unwrap();
let should_reduce = metadata.should_reduce.make_false();
@ -130,7 +130,7 @@ impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> {
self.ids
.get(&Variable::uint(id.clone(), range))
.cloned()
.expect(&format!("identifier should have been defined: {}", id)),
.unwrap_or_else(|| panic!("identifier should have been defined: {}", id)),
),
Add(box left, box right) => {
// reduce the two terms
@ -145,7 +145,6 @@ impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> {
.map(|max| (false, false, max))
.unwrap_or_else(|| {
range_max
.clone()
.checked_add(&right_max)
.map(|max| (true, false, max))
.unwrap_or_else(|| {
@ -203,7 +202,7 @@ impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> {
// if and only if `right_bitwidth` is `T::get_required_bits() - 1`, then `offset` is out of the interval
// [0, 2**(max_bitwidth)[, therefore we need to reduce `right`
left_max
.checked_add(&target_offset.clone())
.checked_add(&target_offset)
.map(|max| (false, true, max))
.unwrap_or_else(|| (true, true, range_max.clone() + target_offset))
} else {
@ -270,7 +269,6 @@ impl<'ast, T: Field> Folder<'ast, T> for UintOptimizer<'ast, T> {
.map(|max| (false, false, max))
.unwrap_or_else(|| {
range_max
.clone()
.checked_mul(&right_max)
.map(|max| (true, false, max))
.unwrap_or_else(|| {

6
zokrates_core/src/static_analysis/unroll.rs
View file

@ -121,9 +121,9 @@ impl<'ast, T: Field> Folder<'ast, T> for Unroller<'ast> {
stats.clone(),
]
.into_iter()
.flat_map(|x| x)
.flatten()
})
.flat_map(|x| x)
.flatten()
.flat_map(|x| self.fold_statement(x))
.collect();
@ -150,7 +150,7 @@ impl<'ast, T: Field> Folder<'ast, T> for Unroller<'ast> {
fn fold_name(&mut self, n: Identifier<'ast>) -> Identifier<'ast> {
Identifier {
version: self.substitution.get(&n.id).unwrap_or(&0).clone(),
version: *self.substitution.get(&n.id).unwrap_or(&0),
..n
}
}

24
zokrates_core/src/static_analysis/variable_read_remover.rs
View file

@ -56,8 +56,7 @@ impl<'ast, T: Field> VariableReadRemover<'ast, T> {
Some(acc) => Some(BooleanExpression::Or(box acc, box e)),
None => Some(e),
})
.unwrap()
.into(),
.unwrap(),
));
(0..size)
@ -179,19 +178,16 @@ mod tests {
assert_eq!(
VariableReadRemover::new().fold_statement(access),
vec![
TypedStatement::Assertion(
BooleanExpression::Or(
box BooleanExpression::UintEq(
box UExpressionInner::Identifier("i".into()).annotate(UBitwidth::B32),
box UExpressionInner::Value(0).annotate(UBitwidth::B32)
),
box BooleanExpression::UintEq(
box UExpressionInner::Identifier("i".into()).annotate(UBitwidth::B32),
box UExpressionInner::Value(1).annotate(UBitwidth::B32)
)
TypedStatement::Assertion(BooleanExpression::Or(
box BooleanExpression::UintEq(
box UExpressionInner::Identifier("i".into()).annotate(UBitwidth::B32),
box UExpressionInner::Value(0).annotate(UBitwidth::B32)
),
box BooleanExpression::UintEq(
box UExpressionInner::Identifier("i".into()).annotate(UBitwidth::B32),
box UExpressionInner::Value(1).annotate(UBitwidth::B32)
)
.into(),
),
)),
TypedStatement::Definition(
TypedAssignee::Identifier(Variable::field_element("b")),
FieldElementExpression::if_else(

31
zokrates_core/src/typed_absy/integer.rs
View file

@ -299,18 +299,15 @@ impl<'ast, T: Field> UExpression<'ast, T> {
Err(Value(i))
}
}
Add(box e1, box e2) => Ok(UExpression::add(
Self::try_from_int(e1, bitwidth)?,
Self::try_from_int(e2, bitwidth)?,
)),
Sub(box e1, box e2) => Ok(UExpression::sub(
Self::try_from_int(e1, bitwidth)?,
Self::try_from_int(e2, bitwidth)?,
)),
Mult(box e1, box e2) => Ok(UExpression::mult(
Self::try_from_int(e1, bitwidth)?,
Self::try_from_int(e2, bitwidth)?,
)),
Add(box e1, box e2) => {
Ok(Self::try_from_int(e1, bitwidth)? + Self::try_from_int(e2, bitwidth)?)
}
Sub(box e1, box e2) => {
Ok(Self::try_from_int(e1, bitwidth)? - Self::try_from_int(e2, bitwidth)?)
}
Mult(box e1, box e2) => {
Ok(Self::try_from_int(e1, bitwidth)? * Self::try_from_int(e2, bitwidth)?)
}
And(box e1, box e2) => Ok(UExpression::and(
Self::try_from_int(e1, bitwidth)?,
Self::try_from_int(e2, bitwidth)?,
@ -319,7 +316,7 @@ impl<'ast, T: Field> UExpression<'ast, T> {
Self::try_from_int(e1, bitwidth)?,
Self::try_from_int(e2, bitwidth)?,
)),
Not(box e) => Ok(UExpression::not(Self::try_from_int(e, bitwidth)?)),
Not(box e) => Ok(!Self::try_from_int(e, bitwidth)?),
Xor(box e1, box e2) => Ok(UExpression::xor(
Self::try_from_int(e1, bitwidth)?,
Self::try_from_int(e2, bitwidth)?,
@ -551,15 +548,15 @@ mod tests {
let expected = vec![
t.clone(),
UExpression::add(t.clone(), t.clone()),
t.clone() + t.clone(),
UExpression::xor(t.clone(), t.clone()),
UExpression::or(t.clone(), t.clone()),
UExpression::and(t.clone(), t.clone()),
UExpression::sub(t.clone(), t.clone()),
UExpression::mult(t.clone(), t.clone()),
t.clone() - t.clone(),
t.clone() * t.clone(),
UExpression::left_shift(t.clone(), s.clone()),
UExpression::right_shift(t.clone(), s.clone()),
UExpression::not(t.clone()),
!t.clone(),
UExpression::if_else(c.clone(), t.clone(), t.clone()),
UExpression::select(t_a.clone(), i.clone()),
];

14
zokrates_core/src/typed_absy/mod.rs
View file

@ -123,7 +123,7 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedProgram<'ast, T> {
writeln!(f, "{}", "-".repeat(100))?;
writeln!(f, "{}", module)?;
writeln!(f, "{}", "-".repeat(100))?;
writeln!(f, "")?;
writeln!(f)?;
}
write!(f, "")
}
@ -265,7 +265,7 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedFunction<'ast, T> {
}
)?;
writeln!(f, "")?;
writeln!(f)?;
let mut tab = 0;
@ -406,9 +406,9 @@ impl<'ast, T: fmt::Debug> fmt::Debug for TypedStatement<'ast, T> {
}
TypedStatement::Assertion(ref e) => write!(f, "Assertion({:?})", e),
TypedStatement::For(ref var, ref start, ref stop, ref list) => {
write!(f, "for {:?} in {:?}..{:?} do\n", var, start, stop)?;
writeln!(f, "for {:?} in {:?}..{:?} do", var, start, stop)?;
for l in list {
write!(f, "\t\t{:?}\n", l)?;
writeln!(f, "\t\t{:?}", l)?;
}
write!(f, "\tendfor")
}
@ -431,7 +431,7 @@ impl<'ast, T: fmt::Display> TypedStatement<'ast, T> {
writeln!(f, "for {} in {}..{} do", variable, from, to)?;
for s in statements {
s.fmt_indented(f, depth + 1)?;
writeln!(f, "")?;
writeln!(f)?;
}
write!(f, "{}endfor", "\t".repeat(depth))
}
@ -457,9 +457,9 @@ impl<'ast, T: fmt::Display> fmt::Display for TypedStatement<'ast, T> {
TypedStatement::Definition(ref lhs, ref rhs) => write!(f, "{} = {}", lhs, rhs),
TypedStatement::Assertion(ref e) => write!(f, "assert({})", e),
TypedStatement::For(ref var, ref start, ref stop, ref list) => {
write!(f, "for {} in {}..{} do\n", var, start, stop)?;
writeln!(f, "for {} in {}..{} do", var, start, stop)?;
for l in list {
write!(f, "\t\t{}\n", l)?;
writeln!(f, "\t\t{}", l)?;
}
write!(f, "\tendfor")
}

8
zokrates_core/src/typed_absy/types.rs
View file

@ -1112,12 +1112,10 @@ pub mod signature {
let len = res.len();
if len == 0 {
res.push((1, t))
} else if res[len - 1].1 == t {
res[len - 1].0 += 1;
} else {
if res[len - 1].1 == t {
res[len - 1].0 += 1;
} else {
res.push((1, t))
}
res.push((1, t))
}
}
res.into_iter()

47
zokrates_core/src/typed_absy/uint.rs
View file

@ -1,40 +1,70 @@
use crate::typed_absy::types::UBitwidth;
use crate::typed_absy::*;
use std::ops::{Add, Div, Mul, Not, Rem, Sub};
use zokrates_field::Field;
type Bitwidth = usize;
impl<'ast, T: Field> UExpression<'ast, T> {
pub fn add(self, other: Self) -> UExpression<'ast, T> {
impl<'ast, T> Add for UExpression<'ast, T> {
type Output = Self;
fn add(self, other: Self) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
assert_eq!(bitwidth, other.bitwidth);
UExpressionInner::Add(box self, box other).annotate(bitwidth)
}
}
pub fn sub(self, other: Self) -> UExpression<'ast, T> {
impl<'ast, T> Sub for UExpression<'ast, T> {
type Output = Self;
fn sub(self, other: Self) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
assert_eq!(bitwidth, other.bitwidth);
UExpressionInner::Sub(box self, box other).annotate(bitwidth)
}
}
pub fn mult(self, other: Self) -> UExpression<'ast, T> {
impl<'ast, T> Mul for UExpression<'ast, T> {
type Output = Self;
fn mul(self, other: Self) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
assert_eq!(bitwidth, other.bitwidth);
UExpressionInner::Mult(box self, box other).annotate(bitwidth)
}
}
pub fn div(self, other: Self) -> UExpression<'ast, T> {
impl<'ast, T> Div for UExpression<'ast, T> {
type Output = Self;
fn div(self, other: Self) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
assert_eq!(bitwidth, other.bitwidth);
UExpressionInner::Div(box self, box other).annotate(bitwidth)
}
}
pub fn rem(self, other: Self) -> UExpression<'ast, T> {
impl<'ast, T> Rem for UExpression<'ast, T> {
type Output = Self;
fn rem(self, other: Self) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
assert_eq!(bitwidth, other.bitwidth);
UExpressionInner::Rem(box self, box other).annotate(bitwidth)
}
}
impl<'ast, T> Not for UExpression<'ast, T> {
type Output = Self;
fn not(self) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
UExpressionInner::Not(box self).annotate(bitwidth)
}
}
impl<'ast, T: Field> UExpression<'ast, T> {
pub fn xor(self, other: Self) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
assert_eq!(bitwidth, other.bitwidth);
@ -53,11 +83,6 @@ impl<'ast, T: Field> UExpression<'ast, T> {
UExpressionInner::And(box self, box other).annotate(bitwidth)
}
pub fn not(self) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
UExpressionInner::Not(box self).annotate(bitwidth)
}
pub fn left_shift(self, by: FieldElementExpression<'ast, T>) -> UExpression<'ast, T> {
let bitwidth = self.bitwidth;
UExpressionInner::LeftShift(box self, box by).annotate(bitwidth)

4
zokrates_core/src/zir/from_typed.rs
View file

@ -13,8 +13,8 @@ impl<'ast> From<typed_absy::types::ConcreteFunctionKey<'ast>> for zir::types::Fu
impl From<typed_absy::types::ConcreteSignature> for zir::types::Signature {
fn from(s: typed_absy::types::ConcreteSignature) -> zir::types::Signature {
zir::types::Signature {
inputs: s.inputs.into_iter().flat_map(|t| from_type(t)).collect(),
outputs: s.outputs.into_iter().flat_map(|t| from_type(t)).collect(),
inputs: s.inputs.into_iter().flat_map(from_type).collect(),
outputs: s.outputs.into_iter().flat_map(from_type).collect(),
}
}
}

2
zokrates_core/src/zir/mod.rs
View file

@ -58,7 +58,7 @@ impl<'ast, T: fmt::Display> fmt::Display for ZirProgram<'ast, T> {
writeln!(f, "{}", "-".repeat(100))?;
writeln!(f, "{}", module)?;
writeln!(f, "{}", "-".repeat(100))?;
writeln!(f, "")?;
writeln!(f)?;
}
write!(f, "")
}

8
zokrates_core/src/zir/types.rs
View file

@ -200,12 +200,10 @@ pub mod signature {
let len = res.len();
if len == 0 {
res.push((1, t))
} else if res[len - 1].1 == t {
res[len - 1].0 += 1;
} else {
if res[len - 1].1 == t {
res[len - 1].0 += 1;
} else {
res.push((1, t))
}
res.push((1, t))
}
}
res.into_iter()

2
zokrates_core_test/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_core_test"
version = "0.1.3"
version = "0.1.4"
authors = ["schaeff <thibaut@schaeff.fr>"]
edition = "2018"

4
zokrates_field/src/lib.rs
View file

@ -94,7 +94,7 @@ pub trait Field:
/// Returns the number of bits required to represent any element of this field type.
fn get_required_bits() -> usize;
/// Tries to parse a string into this representation
fn try_from_dec_str<'a>(s: &'a str) -> Result<Self, ()>;
fn try_from_dec_str(s: &str) -> Result<Self, ()>;
fn try_from_str(s: &str, radix: u32) -> Result<Self, ()>;
/// Returns a decimal string representing a the member of the equivalence class of this `Field` in Z/pZ
/// which lies in [-(p-1)/2, (p-1)/2]
@ -208,7 +208,7 @@ mod prime_field {
fn get_required_bits() -> usize {
(*P).bits()
}
fn try_from_dec_str<'a>(s: &'a str) -> Result<Self, ()> {
fn try_from_dec_str(s: &str) -> Result<Self, ()> {
Self::try_from_str(s, 10)
}
fn try_from_str(s: &str, radix: u32) -> Result<Self, ()> {

10
zokrates_fs_resolver/src/lib.rs
View file

@ -37,14 +37,12 @@ impl<'a> Resolver<io::Error> for FileSystemResolver<'a> {
// other paths `abc/def` are interpreted relative to the standard library root path
let base = match source.components().next() {
Some(Component::CurDir) | Some(Component::ParentDir) => {
PathBuf::from(current_location).parent().unwrap().into()
current_location.parent().unwrap().into()
}
_ => PathBuf::from(self.stdlib_root_path.unwrap_or("")),
};
let path_owned = base
.join(PathBuf::from(import_location.clone()))
.with_extension("zok");
let path_owned = base.join(import_location.clone()).with_extension("zok");
if !path_owned.is_file() {
return Err(io::Error::new(
@ -96,7 +94,7 @@ mod tests {
// create a source folder with a zok file
let folder = tempfile::tempdir().unwrap();
let dir_path = folder.path().join("dir");
std::fs::create_dir(dir_path.clone()).unwrap();
std::fs::create_dir(dir_path).unwrap();
let fs_resolver = FileSystemResolver::default();
let res = fs_resolver.resolve(".".into(), "./dir/".into());
@ -155,7 +153,7 @@ mod tests {
let stdlib_root_path = temp_dir.path().to_owned();
let fs_resolver = FileSystemResolver::with_stdlib_root(stdlib_root_path.to_str().unwrap());
let result = fs_resolver.resolve(file_path.clone(), "bar.zok".into());
let result = fs_resolver.resolve(file_path, "bar.zok".into());
assert!(result.is_ok());
// the imported file should be the user's
assert_eq!(result.unwrap().0, String::from("<stdlib code>\n"));

2
zokrates_js/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_js"
version = "1.0.26"
version = "1.0.27"
authors = ["Darko Macesic"]
edition = "2018"

2
zokrates_js/package.json
View file

@ -2,7 +2,7 @@
"name": "zokrates-js",
"main": "index.js",
"author": "Darko Macesic <darem966@gmail.com>",
"version": "1.0.26",
"version": "1.0.27",
"keywords": [
"zokrates",
"wasm-bindgen",

2
zokrates_parser/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_parser"
version = "0.1.5"
version = "0.1.6"
authors = ["JacobEberhardt <jacob.eberhardt@tu-berlin.de>"]
edition = "2018"

2
zokrates_pest_ast/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "zokrates_pest_ast"
version = "0.1.4"
version = "0.1.5"
authors = ["schaeff <thibaut@schaeff.fr>"]
edition = "2018"

2
zokrates_pest_ast/src/lib.rs
View file

@ -852,7 +852,7 @@ impl fmt::Display for Error {
}
pub fn generate_ast(input: &str) -> Result<ast::File, Error> {
let parse_tree = parse(input).map_err(|e| Error(e))?;
let parse_tree = parse(input).map_err(Error)?;
Ok(Prog::from(parse_tree).0)
}

2
zokrates_stdlib/build.rs
View file

@ -15,5 +15,5 @@ fn export_stdlib() {
let out_dir = env::var("OUT_DIR").unwrap();
let mut options = CopyOptions::new();
options.overwrite = true;
copy_items(&vec!["stdlib"], out_dir, &options).unwrap();
copy_items(&["stdlib"], out_dir, &options).unwrap();
}

2
zokrates_test/src/lib.rs
View file

@ -154,7 +154,7 @@ fn compile_and_run<T: Field>(t: Tests) {
s,
input
.iter()
.map(|i| format!("{}", i))
.map(|i| i.to_string())
.collect::<Vec<_>>()
.join(", ")
);