ProvableHQ/leo
1
1
Fork 0
mirror of https://github.com/ProvableHQ/leo.git synced 2024-12-28 12:45:26 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:AleoHQ/leo into feature/license-header

Browse Source
This commit is contained in:
collin 2020-10-21 12:18:54 -07:00
commit c9b7b0ccc6
250 changed files with 3463 additions and 1971 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
.github/workflows/ci.yml vendored
View File

@ -15,14 +15,6 @@ jobs:
- name: Checkout
uses: actions/checkout@v1
- name: Load snarkOS
run: |
mkdir ~/.ssh
echo "${{ secrets.SNARKOS_DEPLOY_KEY }}" > ~/.ssh/id_rsa
chmod 600 ~/.ssh/id_rsa
eval $(ssh-agent -s)
ssh-add -k ~/.ssh/id_rsa
- name: Install Rust
uses: actions-rs/toolchain@v1
with:
@ -53,14 +45,6 @@ jobs:
- name: Checkout
uses: actions/checkout@v2
- name: Load snarkOS
run: |
mkdir ~/.ssh
echo "${{ secrets.SNARKOS_DEPLOY_KEY }}" > ~/.ssh/id_rsa
chmod 600 ~/.ssh/id_rsa
eval $(ssh-agent -s)
ssh-add -k ~/.ssh/id_rsa
- name: Install Rust (${{ matrix.rust }})
uses: actions-rs/toolchain@v1
with:
@ -131,14 +115,6 @@ jobs:
- name: Checkout
uses: actions/checkout@v1
- name: Load snarkOS
run: |
mkdir ~/.ssh
echo "${{ secrets.SNARKOS_DEPLOY_KEY }}" > ~/.ssh/id_rsa
chmod 600 ~/.ssh/id_rsa
eval $(ssh-agent -s)
ssh-add -k ~/.ssh/id_rsa
- name: Install Rust
uses: actions-rs/toolchain@v1
with:

16
.github/workflows/release-tests.yml vendored
View File

@ -15,14 +15,6 @@ jobs:
- name: Checkout
uses: actions/checkout@v1
- name: Load snarkOS
run: |
mkdir ~/.ssh
echo "${{ secrets.SNARKOS_DEPLOY_KEY }}" > ~/.ssh/id_rsa
chmod 600 ~/.ssh/id_rsa
eval $(ssh-agent -s)
ssh-add -k ~/.ssh/id_rsa
- name: Install Rust
uses: actions-rs/toolchain@v1
with:
@ -54,14 +46,6 @@ jobs:
- name: Checkout
uses: actions/checkout@v1
- name: Load snarkOS
run: |
mkdir ~/.ssh
echo "${{ secrets.SNARKOS_DEPLOY_KEY }}" > ~/.ssh/id_rsa
chmod 600 ~/.ssh/id_rsa
eval $(ssh-agent -s)
ssh-add -k ~/.ssh/id_rsa
- name: Install Rust
uses: actions-rs/toolchain@v1
with:

29
Cargo.lock generated
View File

@ -2233,9 +2233,9 @@ dependencies = [
[[package]]
name = "self_update"
version = "0.19.0"
version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ad4f32cc38aac660a9a872b5553677d59f984139f3316f642989d8232be3e5c"
checksum = "c047c1227ffcf31a3b6f64df97c61e79539721facef7ff06a2ece7a7f3052f1f"
dependencies = [
"hyper-old-types",
"indicatif",
@ -2266,9 +2266,9 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
[[package]]
name = "serde"
version = "1.0.115"
version = "1.0.116"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e54c9a88f2da7238af84b5101443f0c0d0a3bbdc455e34a5c9497b1903ed55d5"
checksum = "96fe57af81d28386a513cbc6858332abc6117cfdb5999647c6444b8f43a370a5"
dependencies = [
"serde_derive",
]
@ -2285,9 +2285,9 @@ dependencies = [
[[package]]
name = "serde_derive"
version = "1.0.115"
version = "1.0.116"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "609feed1d0a73cc36a0182a840a9b37b4a82f0b1150369f0536a9e3f2a31dc48"
checksum = "f630a6370fd8e457873b4bd2ffdae75408bc291ba72be773772a4c2a065d9ae8"
dependencies = [
"proc-macro2 1.0.19",
"quote 1.0.7",
@ -2796,12 +2796,13 @@ checksum = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"
[[package]]
name = "tracing"
version = "0.1.19"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6d79ca061b032d6ce30c660fded31189ca0b9922bf483cd70759f13a2d86786c"
checksum = "b0987850db3733619253fe60e17cb59b82d37c7e6c0236bb81e4d6b87c879f27"
dependencies = [
"cfg-if",
"log",
"pin-project-lite",
"tracing-attributes",
"tracing-core",
]
@ -2819,9 +2820,9 @@ dependencies = [
[[package]]
name = "tracing-core"
version = "0.1.15"
version = "0.1.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f0e00789804e99b20f12bc7003ca416309d28a6f495d6af58d1e2c2842461b5"
checksum = "f50de3927f93d202783f4513cda820ab47ef17f624b03c096e86ef00c67e6b5f"
dependencies = [
"lazy_static",
]
@ -2839,9 +2840,9 @@ dependencies = [
[[package]]
name = "tracing-serde"
version = "0.1.1"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6ccba2f8f16e0ed268fc765d9b7ff22e965e7185d32f8f1ec8294fe17d86e79"
checksum = "fb65ea441fbb84f9f6748fd496cf7f63ec9af5bca94dd86456978d055e8eb28b"
dependencies = [
"serde",
"tracing-core",
@ -2849,9 +2850,9 @@ dependencies = [
[[package]]
name = "tracing-subscriber"
version = "0.2.11"
version = "0.2.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "abd165311cc4d7a555ad11cc77a37756df836182db0d81aac908c8184c584f40"
checksum = "82bb5079aa76438620837198db8a5c529fb9878c730bc2b28179b0241cf04c10"
dependencies = [
"ansi_term 0.12.1",
"chrono",

2
Cargo.toml
View File

@ -125,7 +125,7 @@ version = "0.10.7"
features = [ "blocking", "json" ]
[dependencies.self_update]
version = "0.19.0"
version = "0.20.0"
features = [ "archive-zip" ]
[dependencies.serde]

11
ast/benches/ast.rs
View File

@ -14,24 +14,21 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use leo_ast::{errors::ParserError, files::File, LeoAst};
use leo_ast::LeoAst;
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use std::path::{Path, PathBuf};
use std::path::Path;
fn leo_ast<'ast>(filepath: &'ast PathBuf, program_string: &'ast str) {
fn leo_ast<'ast>(filepath: &'ast Path, program_string: &'ast str) {
let result = LeoAst::<'ast>::new(filepath, program_string).unwrap();
black_box(result);
}
fn criterion_benchmark(c: &mut Criterion) {
let filepath = Path::new("./main.leo").to_path_buf();
// let program_string = &LeoAst::load_file(&filepath).unwrap();
let program_string = include_str!("./main.leo");
c.bench_function("LeoAst::new", |b| {
b.iter(|| leo_ast(black_box(&filepath), black_box(program_string)))
});
c.bench_function("LeoAst::new", |b| b.iter(|| leo_ast(&filepath, program_string)));
}
criterion_group!(benches, criterion_benchmark);

27
ast/benches/main.leo
View File

@ -1,3 +1,26 @@
function main() {
return 1 + 1
circuit PedersenHash {
parameters: [group; 256],
// Instantiates a Pedersen hash circuit
static function new(parameters: [group; 256]) -> Self {
return Self { parameters: parameters }
}
function hash(bits: [bool; 256]) -> group {
let mut digest: group = 0;
for i in 0..256 {
if bits[i] {
digest += self.parameters[i];
}
}
return digest
}
}
// The 'pedersen-hash' main function.
function main() -> group {
const parameters = [1group; 256];
const pedersen = PedersenHash::new(parameters);
let hash_input: [bool; 256] = [true; 256];
return pedersen.hash(hash_input)
}

4
ast/src/access/call_access.rs
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::{ast::Rule, expressions::TupleExpression, SpanDef};
use crate::{ast::Rule, expressions::Expression, SpanDef};
use pest::Span;
use pest_ast::FromPest;
@ -23,7 +23,7 @@ use serde::Serialize;
#[derive(Clone, Debug, FromPest, PartialEq, Serialize)]
#[pest_ast(rule(Rule::access_call))]
pub struct CallAccess<'ast> {
pub expressions: TupleExpression<'ast>,
pub expressions: Vec<Expression<'ast>>,
#[pest_ast(outer())]
#[serde(with = "SpanDef")]
pub span: Span<'ast>,

2
ast/src/access/mod.rs
View File

@ -14,6 +14,8 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
#![allow(clippy::module_inception)]
pub mod access;
pub use access::*;

2
ast/src/annotations/mod.rs
View File

@ -14,6 +14,8 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
#![allow(clippy::module_inception)]
pub mod annotations;
pub use annotations::*;

30
ast/src/ast.rs
View File

@ -74,8 +74,8 @@ fn precedence_climber() -> PrecClimber<Rule> {
])
}
fn parse_term(pair: Pair<Rule>) -> Box<Expression> {
Box::new(match pair.as_rule() {
fn parse_term(pair: Pair<Rule>) -> Expression {
match pair.as_rule() {
Rule::expression_term => {
let clone = pair.clone();
let next = clone.into_inner().next().unwrap();
@ -87,14 +87,14 @@ fn parse_term(pair: Pair<Rule>) -> Box<Expression> {
Rule::expression_array_inline => {
Expression::ArrayInline(ArrayInlineExpression::from_pest(&mut pair.into_inner()).unwrap())
}
Rule::expression_array_initializer => {
Expression::ArrayInitializer(ArrayInitializerExpression::from_pest(&mut pair.into_inner()).unwrap())
}
Rule::expression_array_initializer => Expression::ArrayInitializer(Box::new(
ArrayInitializerExpression::from_pest(&mut pair.into_inner()).unwrap(),
)),
Rule::expression_circuit_inline => {
Expression::CircuitInline(CircuitInlineExpression::from_pest(&mut pair.into_inner()).unwrap())
}
Rule::expression_conditional => {
Expression::Ternary(TernaryExpression::from_pest(&mut pair.into_inner()).unwrap())
Expression::Ternary(Box::new(TernaryExpression::from_pest(&mut pair.into_inner()).unwrap()))
}
Rule::expression_unary => {
// The following is necessary to match with the unary operator and its unary expression
@ -107,11 +107,11 @@ fn parse_term(pair: Pair<Rule>) -> Box<Expression> {
rule => unreachable!("`expression_unary` should yield `operation_unary`, found {:#?}", rule),
};
let expression = parse_term(inner.next().unwrap());
Expression::Unary(UnaryExpression {
Expression::Unary(Box::new(UnaryExpression {
operation,
expression,
span,
})
}))
}
Rule::expression_postfix => {
Expression::Postfix(PostfixExpression::from_pest(&mut pair.into_inner()).unwrap())
@ -128,19 +128,15 @@ fn parse_term(pair: Pair<Rule>) -> Box<Expression> {
"`parse_expression_term` should be invoked on `Rule::expression_term`, found {:#?}",
rule
),
})
}
}
fn binary_expression<'ast>(
lhs: Box<Expression<'ast>>,
pair: Pair<'ast, Rule>,
rhs: Box<Expression<'ast>>,
) -> Box<Expression<'ast>> {
fn binary_expression<'ast>(lhs: Expression<'ast>, pair: Pair<'ast, Rule>, rhs: Expression<'ast>) -> Expression<'ast> {
let (start, _) = lhs.span().clone().split();
let (_, end) = rhs.span().clone().split();
let span = start.span(&end);
Box::new(match pair.as_rule() {
match pair.as_rule() {
Rule::operation_or => Expression::binary(BinaryOperation::Or, lhs, rhs, span),
Rule::operation_and => Expression::binary(BinaryOperation::And, lhs, rhs, span),
Rule::operation_eq => Expression::binary(BinaryOperation::Eq, lhs, rhs, span),
@ -155,7 +151,7 @@ fn binary_expression<'ast>(
Rule::operation_div => Expression::binary(BinaryOperation::Div, lhs, rhs, span),
Rule::operation_pow => Expression::binary(BinaryOperation::Pow, lhs, rhs, span),
_ => unreachable!(),
})
}
}
impl<'ast> FromPest<'ast> for Expression<'ast> {
@ -169,7 +165,7 @@ impl<'ast> FromPest<'ast> for Expression<'ast> {
Rule::expression => {
// Transfer iterated state to pest.
*pest = clone;
Ok(*PRECEDENCE_CLIMBER.climb(pair.into_inner(), parse_term, binary_expression))
Ok(PRECEDENCE_CLIMBER.climb(pair.into_inner(), parse_term, binary_expression))
}
_ => Err(ConversionError::NoMatch),
}

12
ast/src/common/range_or_expression.rs
View File

@ -34,8 +34,16 @@ impl<'ast> fmt::Display for RangeOrExpression<'ast> {
RangeOrExpression::Range(ref range) => write!(
f,
"{}..{}",
range.from.as_ref().map(|v| format!("{}", v)).unwrap_or(format!("")),
range.to.as_ref().map(|v| format!("{}", v)).unwrap_or(format!("")),
range
.from
.as_ref()
.map(|v| v.to_string())
.unwrap_or_else(|| "".to_string()),
range
.to
.as_ref()
.map(|v| v.to_string())
.unwrap_or_else(|| "".to_string()),
),
}
}

7
ast/src/common/variables.rs
View File

@ -38,12 +38,7 @@ impl<'ast> fmt::Display for Variables<'ast> {
write!(f, "{}", self.names[0])?;
} else {
// (a, mut b)
let names = self
.names
.iter()
.map(|x| format!("{}", x))
.collect::<Vec<_>>()
.join(",");
let names = self.names.iter().map(|x| x.to_string()).collect::<Vec<_>>().join(",");
write!(f, "({})", names)?;
}

27
ast/src/errors/parser.rs
View File

@ -17,7 +17,7 @@
use crate::{ast::Rule, errors::SyntaxError};
use pest::error::Error;
use std::path::PathBuf;
use std::path::{Path, PathBuf};
#[derive(Debug, Error)]
pub enum ParserError {
@ -38,21 +38,18 @@ pub enum ParserError {
}
impl ParserError {
pub fn set_path(&mut self, path: PathBuf) {
match self {
ParserError::SyntaxError(error) => {
let new_error: Error<Rule> = match error {
SyntaxError::Error(error) => {
let new_error = error.clone();
new_error.with_path(path.to_str().unwrap())
}
};
pub fn set_path(&mut self, path: &Path) {
if let ParserError::SyntaxError(error) = self {
let new_error: Error<Rule> = match error {
SyntaxError::Error(error) => {
let new_error = error.clone();
new_error.with_path(path.to_str().unwrap())
}
};
tracing::error!("{}", new_error);
tracing::error!("{}", new_error);
*error = SyntaxError::Error(new_error);
}
_ => {}
*error = SyntaxError::Error(new_error);
}
}
}
@ -65,6 +62,6 @@ impl From<Error<Rule>> for ParserError {
impl From<std::io::Error> for ParserError {
fn from(error: std::io::Error) -> Self {
ParserError::Crate("std::io", format!("{}", error))
ParserError::Crate("std::io", error.to_string())
}
}

2
ast/src/expressions/array_initializer_expression.rs
View File

@ -23,7 +23,7 @@ use serde::Serialize;
#[derive(Clone, Debug, FromPest, PartialEq, Serialize)]
#[pest_ast(rule(Rule::expression_array_initializer))]
pub struct ArrayInitializerExpression<'ast> {
pub expression: Box<Expression<'ast>>,
pub expression: Expression<'ast>,
pub dimensions: ArrayDimensions<'ast>,
#[pest_ast(outer())]
#[serde(with = "SpanDef")]

4
ast/src/expressions/binary_expression.rs
View File

@ -22,8 +22,8 @@ use serde::Serialize;
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct BinaryExpression<'ast> {
pub operation: BinaryOperation,
pub left: Box<Expression<'ast>>,
pub right: Box<Expression<'ast>>,
pub left: Expression<'ast>,
pub right: Expression<'ast>,
#[serde(with = "SpanDef")]
pub span: Span<'ast>,
}

26
ast/src/expressions/expression.rs
View File

@ -24,11 +24,11 @@ use std::fmt;
pub enum Expression<'ast> {
Value(Value<'ast>),
Identifier(Identifier<'ast>),
Unary(UnaryExpression<'ast>),
Binary(BinaryExpression<'ast>),
Ternary(TernaryExpression<'ast>),
Unary(Box<UnaryExpression<'ast>>),
Binary(Box<BinaryExpression<'ast>>),
Ternary(Box<TernaryExpression<'ast>>),
ArrayInline(ArrayInlineExpression<'ast>),
ArrayInitializer(ArrayInitializerExpression<'ast>),
ArrayInitializer(Box<ArrayInitializerExpression<'ast>>),
CircuitInline(CircuitInlineExpression<'ast>),
Postfix(PostfixExpression<'ast>),
Tuple(TupleExpression<'ast>),
@ -37,30 +37,30 @@ pub enum Expression<'ast> {
impl<'ast> Expression<'ast> {
pub fn binary(
operation: BinaryOperation,
left: Box<Expression<'ast>>,
right: Box<Expression<'ast>>,
left: Expression<'ast>,
right: Expression<'ast>,
span: Span<'ast>,
) -> Self {
Expression::Binary(BinaryExpression {
Expression::Binary(Box::new(BinaryExpression {
operation,
left,
right,
span,
})
}))
}
pub fn ternary(
first: Box<Expression<'ast>>,
second: Box<Expression<'ast>>,
third: Box<Expression<'ast>>,
first: Expression<'ast>,
second: Expression<'ast>,
third: Expression<'ast>,
span: Span<'ast>,
) -> Self {
Expression::Ternary(TernaryExpression {
Expression::Ternary(Box::new(TernaryExpression {
first,
second,
third,
span,
})
}))
}
pub fn span(&self) -> &Span<'ast> {

6
ast/src/expressions/ternary_expression.rs
View File

@ -23,9 +23,9 @@ use serde::Serialize;
#[derive(Clone, Debug, FromPest, PartialEq, Serialize)]
#[pest_ast(rule(Rule::expression_conditional))]
pub struct TernaryExpression<'ast> {
pub first: Box<Expression<'ast>>,
pub second: Box<Expression<'ast>>,
pub third: Box<Expression<'ast>>,
pub first: Expression<'ast>,
pub second: Expression<'ast>,
pub third: Expression<'ast>,
#[pest_ast(outer())]
#[serde(with = "SpanDef")]
pub span: Span<'ast>,

2
ast/src/expressions/unary_expression.rs
View File

@ -25,7 +25,7 @@ use std::fmt;
#[pest_ast(rule(Rule::expression_unary))]
pub struct UnaryExpression<'ast> {
pub operation: UnaryOperation,
pub expression: Box<Expression<'ast>>,
pub expression: Expression<'ast>,
#[pest_ast(outer())]
#[serde(with = "SpanDef")]
pub span: Span<'ast>,

2
ast/src/functions/input/mod.rs
View File

@ -14,6 +14,8 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
#![allow(clippy::module_inception)]
pub mod function_input;
pub use function_input::*;

6
ast/src/leo.pest
View File

@ -226,7 +226,7 @@ dimension_single = {
// Declared in types/array_dimensions.rs
dimension_multiple = { "(" ~ number_positive ~ ("," ~ number_positive)* ~ ")"}
type_tuple = { "(" ~ NEWLINE* ~ type_ ~ ("," ~ NEWLINE* ~ type_)+ ~ ","? ~ NEWLINE* ~ ")" }
type_tuple = { "(" ~ NEWLINE* ~ (type_ ~ ("," ~ NEWLINE* ~ type_)+ ~ ","?)? ~ NEWLINE* ~ ")" }
/// Values
@ -302,7 +302,7 @@ access_tuple = ${ "." ~ number_positive }
access_assignee = { access_array | access_tuple | access_member }
// Declared in access/call_access.rs
access_call = !{ expression_tuple }
access_call = !{ "(" ~ (expression ~ ("," ~ expression)*)? ~ ")" }
// Declared in access/member_access.rs
access_member = ${ "." ~ identifier }
@ -351,7 +351,7 @@ expression_term = {
expression = { expression_term ~ (operation_binary ~ expression_term)* }
// Declared in expressions/expression_tuple.rs
expression_tuple = { "(" ~ (expression ~ ("," ~ expression)*)? ~ ")" }
expression_tuple = { "(" ~ (expression ~ ("," ~ expression)+)? ~ ")" }
// Declared in expressions/array_initializer_expression.rs
expression_array_initializer = { "[" ~ expression ~ ";" ~ array_dimensions ~ "]" }

10
ast/src/lib.rs
View File

@ -21,7 +21,7 @@ extern crate pest_derive;
#[macro_use]
extern crate thiserror;
mod ast;
pub mod ast;
pub mod access;
pub mod annotations;
@ -45,7 +45,7 @@ pub(crate) mod span;
pub(crate) use span::*;
use from_pest::FromPest;
use std::{fs, path::PathBuf};
use std::{fs, path::Path};
pub struct LeoAst<'ast> {
ast: files::File<'ast>,
@ -53,7 +53,7 @@ pub struct LeoAst<'ast> {
impl<'ast> LeoAst<'ast> {
/// Creates a new abstract syntax tree given the file path.
pub fn new(file_path: &'ast PathBuf, program_string: &'ast str) -> Result<Self, ParserError> {
pub fn new(file_path: &'ast Path, program_string: &'ast str) -> Result<Self, ParserError> {
// TODO (howardwu): Turn this check back on after fixing the testing module.
// assert_eq!(program_string, fs::read_to_string(file_path).map_err(|_| ParserError::FileReadError(file_path.clone()))?);
@ -71,8 +71,8 @@ impl<'ast> LeoAst<'ast> {
// TODO (howardwu): Remove this in favor of a dedicated file loader to verify checksums
// and maintain a global cache of program strings during the compilation process.
/// Loads the Leo code as a string from the given file path.
pub fn load_file(file_path: &'ast PathBuf) -> Result<String, ParserError> {
Ok(fs::read_to_string(file_path).map_err(|_| ParserError::FileReadError(file_path.clone()))?)
pub fn load_file(file_path: &'ast Path) -> Result<String, ParserError> {
Ok(fs::read_to_string(file_path).map_err(|_| ParserError::FileReadError(file_path.to_owned()))?)
}
/// Returns a reference to the inner abstract syntax tree representation.

6
ast/src/statements/conditional_statement.rs
View File

@ -39,11 +39,11 @@ pub struct ConditionalStatement<'ast> {
impl<'ast> fmt::Display for ConditionalStatement<'ast> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "if ({}) {{\n", self.condition)?;
write!(f, "\t{:#?}\n", self.statements)?;
writeln!(f, "if ({}) {{", self.condition)?;
writeln!(f, "\t{:#?}", self.statements)?;
self.next
.as_ref()
.map(|n_or_e| write!(f, "}} {}", n_or_e))
.unwrap_or(write!(f, "}}"))
.unwrap_or_else(|| write!(f, "}}"))
}
}

2
ast/src/statements/definition_statement.rs
View File

@ -43,7 +43,7 @@ impl<'ast> fmt::Display for DefinitionStatement<'ast> {
let expressions = self
.expressions
.iter()
.map(|x| format!("{}", x))
.map(|x| x.to_string())
.collect::<Vec<_>>()
.join(",");

39
ast/tests/expression.rs Normal file
View File

@ -0,0 +1,39 @@
use leo_ast::ast::{LanguageParser, Rule};
use pest::*;
#[test]
fn redundant_parens() {
parses_to! {
parser: LanguageParser,
input: "(true)",
rule: Rule::expression,
tokens: [
expression(0, 6, [
expression_term(0, 6, [expression(1, 5, [expression_term(1, 5, [value(1, 5, [value_boolean(1, 5, [])])])])])
])
]
}
}
#[test]
fn multiple_redundant_parens() {
parses_to! {
parser: LanguageParser,
input: "(((true)))",
rule: Rule::expression,
tokens: [
expression(0, 10, [
expression_term(0, 10, [
expression(1, 9, [expression_term(1, 9, [
expression(2, 8, [expression_term(2, 8, [
expression(3, 7, [expression_term(3, 7, [
value(3, 7, [value_boolean(3, 7, [])])
])])
])])
])])
])
])
]
}
}

115
ast/tests/function.rs Normal file
View File

@ -0,0 +1,115 @@
use leo_ast::ast::{LanguageParser, Rule};
use pest::*;
#[test]
fn call_wo_args() {
parses_to! {
parser: LanguageParser,
input: "x()",
rule: Rule::expression_postfix,
tokens: [
expression_postfix(0, 3, [
keyword_or_identifier(0, 1, [self_keyword_or_identifier(0, 1, [identifier(0, 1, [])])]),
access(1, 3, [access_call(1, 3, [])])
])
]
}
}
#[test]
fn call_with_arg() {
parses_to! {
parser: LanguageParser,
input: "x(true)",
rule: Rule::expression_postfix,
tokens: [
expression_postfix(0, 7, [
keyword_or_identifier(0, 1, [self_keyword_or_identifier(0, 1, [identifier(0, 1, [])])]),
access(1, 7, [access_call(1, 7, [
expression(2, 6, [expression_term(2, 6, [value(2, 6, [value_boolean(2, 6, [])])])])
])])
])
]
}
}
#[test]
fn call_with_2_args() {
parses_to! {
parser: LanguageParser,
input: "x(true, false)",
rule: Rule::expression_postfix,
tokens: [
expression_postfix(0, 14, [
keyword_or_identifier(0, 1, [self_keyword_or_identifier(0, 1, [identifier(0, 1, [])])]),
access(1, 14, [access_call(1, 14, [
expression(2, 6, [expression_term(2, 6, [value(2, 6, [value_boolean(2, 6, [])])])]),
expression(8, 13, [expression_term(8, 13, [value(8, 13, [value_boolean(8, 13, [])])])])
])])
])
]
}
}
#[test]
fn empty_def() {
parses_to! {
parser: LanguageParser,
input: "function x() {}",
rule: Rule::function,
tokens: [
function(0, 15, [identifier(9, 10, [])])
]
}
}
#[test]
fn returning_unit_type() {
parses_to! {
parser: LanguageParser,
input: "function x() -> () {}",
rule: Rule::function,
tokens: [
function(0, 21, [identifier(9, 10, []), type_(16, 18, [type_tuple(16, 18, [])])])
]
}
}
#[test]
fn returning_unit_value() {
parses_to! {
parser: LanguageParser,
input: "function x() { return () }",
rule: Rule::function,
tokens: [
function(0, 26, [identifier(9, 10, []), statement(15, 25, [
statement_return(15, 25, [expression(22, 25, [expression_term(22, 24, [expression_tuple(22, 24, [])])])])
])])
]
}
}
#[test]
fn id_def() {
parses_to! {
parser: LanguageParser,
input: "function id(x: u8) -> u8 { return x }",
rule: Rule::function,
tokens: [
function(0, 37, [
identifier(9, 11, []),
input(12, 17, [
function_input(12, 17, [
identifier(12, 13, []),
type_(15, 17, [type_data(15, 17, [type_integer(15, 17, [type_integer_unsigned(15, 17, [type_u8(15, 17, [])])])])])
])
]),
type_(22, 24, [type_data(22, 24, [type_integer(22, 24, [type_integer_unsigned(22, 24, [type_u8(22, 24, [])])])])]),
statement(27, 36, [statement_return(27, 36, [
expression(34, 36, [expression_term(34, 35, [identifier(34, 35, [])])])
])])
])
]
}
}

3
ast/tests/mod.rs
View File

@ -14,4 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
mod expression;
mod function;
mod serialization;
mod tuple;

91
ast/tests/tuple.rs Normal file
View File

@ -0,0 +1,91 @@
use leo_ast::ast::{LanguageParser, Rule};
use pest::*;
#[test]
fn implicitly_typed() {
parses_to! {
parser: LanguageParser,
input: "(true, false)",
rule: Rule::expression_tuple,
tokens: [
expression_tuple(0, 13, [
expression(1, 5, [expression_term(1, 5, [value(1, 5, [value_boolean(1, 5, [])])])]),
expression(7, 12, [expression_term(7, 12, [value(7, 12, [value_boolean(7, 12, [])])])])
])
]
}
}
#[test]
fn explicitly_typed() {
parses_to! {
parser: LanguageParser,
input: "let tup: (bool, bool) = (true, false);",
rule: Rule::statement_definition,
tokens: [
statement_definition(0, 38, [
declare(0, 4, [let_(0, 4, [])]),
variables(4, 21, [
variable_name(4, 7, [identifier(4, 7, [])]),
type_(9, 21, [type_tuple(9, 21, [
type_(10, 14, [type_data(10, 14, [type_boolean(10, 14, [])])]),
type_(16, 20, [type_data(16, 20, [type_boolean(16, 20, [])])]),
])])
]),
expression(24, 37, [expression_term(24, 37, [expression_tuple(24, 37, [
expression(25, 29, [expression_term(25, 29, [value(25, 29, [value_boolean(25, 29, [])])])]),
expression(31, 36, [expression_term(31, 36, [value(31, 36, [value_boolean(31, 36, [])])])]),
])])]),
LINE_END(37, 38, [])
])
]
}
}
#[test]
fn access() {
parses_to! {
parser: LanguageParser,
input: "x.0",
rule: Rule::expression_postfix,
tokens: [
expression_postfix(0, 3, [
keyword_or_identifier(0, 1, [self_keyword_or_identifier(0, 1, [identifier(0, 1, [])])]),
access(1, 3, [access_tuple(1, 3, [number_positive(2, 3, [])])])
])
]
}
}
#[test]
fn implicit_unit() {
parses_to! {
parser: LanguageParser,
input: "()",
rule: Rule::expression_tuple,
tokens: [
expression_tuple(0, 2, [])
]
}
}
#[test]
fn explicit_unit() {
parses_to! {
parser: LanguageParser,
input: "let x: () = ();",
rule: Rule::statement_definition,
tokens: [
statement_definition(0, 15, [
declare(0, 4, [let_(0, 4, [])]),
variables(4, 9, [
variable_name(4, 5, [identifier(4, 5, [])]),
type_(7, 9, [type_tuple(7, 9, [])])
]),
expression(12, 14, [expression_term(12, 14, [expression_tuple(12, 14, [])])]),
LINE_END(14, 15, [])
])
]
}
}

29
compiler/src/compiler.rs
View File

@ -38,7 +38,11 @@ use snarkos_models::{
};
use sha2::{Digest, Sha256};
use std::{fs, marker::PhantomData, path::PathBuf};
use std::{
fs,
marker::PhantomData,
path::{Path, PathBuf},
};
#[derive(Clone)]
pub struct Compiler<F: Field + PrimeField, G: GroupType<F>> {
@ -71,17 +75,17 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
pub fn parse_input(
&mut self,
input_string: &str,
input_path: PathBuf,
input_path: &Path,
state_string: &str,
state_path: PathBuf,
state_path: &Path,
) -> Result<(), CompilerError> {
let input_syntax_tree = LeoInputParser::parse_file(&input_string).map_err(|mut e| {
e.set_path(input_path.clone());
e.set_path(input_path);
e
})?;
let state_syntax_tree = LeoInputParser::parse_file(&state_string).map_err(|mut e| {
e.set_path(state_path.clone());
e.set_path(state_path);
e
})?;
@ -121,9 +125,9 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
main_file_path: PathBuf,
output_directory: PathBuf,
input_string: &str,
input_path: PathBuf,
input_path: &Path,
state_string: &str,
state_path: PathBuf,
state_path: &Path,
) -> Result<Self, CompilerError> {
let mut compiler = Self::new(package_name, main_file_path, output_directory);
@ -135,6 +139,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
}
/// Parses the Leo program file, constructs a syntax tree, and generates a program.
#[allow(deprecated)]
pub(crate) fn parse_program(&mut self) -> Result<(), CompilerError> {
// Use the parser to construct the abstract syntax tree.
let program_string = LeoAst::load_file(&self.main_file_path)?;
@ -148,16 +153,16 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
pub fn parse_program_from_string(&mut self, program_string: &str) -> Result<(), CompilerError> {
// Use the given bytes to construct the abstract syntax tree.
let ast = LeoAst::new(&self.main_file_path, &program_string).map_err(|mut e| {
e.set_path(self.main_file_path.clone());
e.set_path(&self.main_file_path);
e
})?;
// Derive the package name.
let package_name = self.package_name.clone();
let package_name = &self.package_name;
// Use the typed parser to construct the typed syntax tree.
let typed_tree = LeoTypedAst::new(&package_name, &ast);
let typed_tree = LeoTypedAst::new(package_name, &ast);
self.program = typed_tree.into_repr();
self.imported_programs = ImportParser::parse(&self.program)?;
@ -201,7 +206,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
generate_constraints::<F, G, CS>(cs, self.program, self.program_input, &self.imported_programs).map_err(
|mut error| {
error.set_path(path);
error.set_path(&path);
error
},
@ -227,7 +232,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> Compiler<F, G> {
let path = self.main_file_path;
generate_constraints::<_, G, _>(cs, self.program, self.program_input, &self.imported_programs).map_err(
|mut error| {
error.set_path(path);
error.set_path(&path);
error
},
)

17
compiler/src/console/assert.rs
View File

@ -28,11 +28,11 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn evaluate_console_assert<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
expression: Expression,
span: Span,
span: &Span,
) -> Result<(), ConsoleError> {
let expected_type = Some(Type::Boolean);
let expression_string = expression.to_string();
@ -53,12 +53,17 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Unwrap assertion value and handle errors
let result_option = match assert_expression {
ConstrainedValue::Boolean(boolean) => boolean.get_value(),
_ => return Err(ConsoleError::assertion_must_be_boolean(expression_string, span.clone())),
_ => {
return Err(ConsoleError::assertion_must_be_boolean(
expression_string,
span.to_owned(),
));
}
};
let result_bool = result_option.ok_or(ConsoleError::assertion_depends_on_input(span.clone()))?;
let result_bool = result_option.ok_or_else(|| ConsoleError::assertion_depends_on_input(span.to_owned()))?;
if !result_bool {
return Err(ConsoleError::assertion_failed(expression_string, span));
return Err(ConsoleError::assertion_failed(expression_string, span.to_owned()));
}
Ok(())

6
compiler/src/console/console.rs
View File

@ -28,14 +28,14 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn evaluate_console_function_call<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
console: ConsoleFunctionCall,
) -> Result<(), ConsoleError> {
match console.function {
ConsoleFunction::Assert(expression) => {
self.evaluate_console_assert(cs, file_scope, function_scope, indicator, expression, console.span)?;
self.evaluate_console_assert(cs, file_scope, function_scope, indicator, expression, &console.span)?;
}
ConsoleFunction::Debug(string) => {
let string = self.format(cs, file_scope, function_scope, string)?;

20
compiler/src/console/format.rs
View File

@ -28,8 +28,8 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn format<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
formatted: FormattedString,
) -> Result<String, ConsoleError> {
// Check that containers and parameters match
@ -37,29 +37,23 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
return Err(ConsoleError::length(
formatted.containers.len(),
formatted.parameters.len(),
formatted.span.clone(),
formatted.span,
));
}
// Trim starting double quote `"`
let mut string = formatted.string.as_str();
string = string.trim_start_matches("\"");
string = string.trim_start_matches('\"');
// Trim everything after the ending double quote `"`
let parts: Vec<&str> = string.split("\"").collect();
string = parts[0];
let string = string.split('\"').next().unwrap();
// Insert the parameter for each container `{}`
let mut result = string.to_string();
for parameter in formatted.parameters.into_iter() {
let parameter_value = self.enforce_expression(
cs,
file_scope.clone(),
function_scope.clone(),
None,
parameter.expression,
)?;
let parameter_value =
self.enforce_expression(cs, file_scope, function_scope, None, parameter.expression)?;
result = result.replacen("{}", &parameter_value.to_string(), 1);
}

18
compiler/src/constraints/constraints.rs
View File

@ -34,7 +34,7 @@ use snarkos_models::{
curves::{Field, PrimeField},
gadgets::r1cs::{ConstraintSystem, TestConstraintSystem},
};
use std::path::PathBuf;
use std::path::Path;
pub fn generate_constraints<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<F>>(
cs: &mut CS,
@ -44,7 +44,7 @@ pub fn generate_constraints<F: Field + PrimeField, G: GroupType<F>, CS: Constrai
) -> Result<OutputBytes, CompilerError> {
let mut resolved_program = ConstrainedProgram::<F, G>::new();
let program_name = program.get_name();
let main_function_name = new_scope(program_name.clone(), "main".into());
let main_function_name = new_scope(&program_name, "main");
resolved_program.store_definitions(program, imported_programs)?;
@ -54,7 +54,7 @@ pub fn generate_constraints<F: Field + PrimeField, G: GroupType<F>, CS: Constrai
match main.clone() {
ConstrainedValue::Function(_circuit_identifier, function) => {
let result = resolved_program.enforce_main_function(cs, program_name, function, input)?;
let result = resolved_program.enforce_main_function(cs, &program_name, function, input)?;
Ok(result)
}
_ => Err(CompilerError::NoMainFunction),
@ -65,8 +65,8 @@ pub fn generate_test_constraints<F: Field + PrimeField, G: GroupType<F>>(
program: Program,
input: InputPairs,
imported_programs: &ImportParser,
main_file_path: &PathBuf,
output_directory: &PathBuf,
main_file_path: &Path,
output_directory: &Path,
) -> Result<(u32, u32), CompilerError> {
let mut resolved_program = ConstrainedProgram::<F, G>::new();
let program_name = program.get_name();
@ -87,7 +87,7 @@ pub fn generate_test_constraints<F: Field + PrimeField, G: GroupType<F>>(
for (test_name, test) in tests.into_iter() {
let cs = &mut TestConstraintSystem::<F>::new();
let full_test_name = format!("{}::{}", program_name.clone(), test_name.to_string());
let full_test_name = format!("{}::{}", program_name.clone(), test_name);
let mut output_file_name = program_name.clone();
// get input file name from annotation or use test_name
@ -118,9 +118,9 @@ pub fn generate_test_constraints<F: Field + PrimeField, G: GroupType<F>>(
input.parse_state(state_ast)?;
// run test function on new program with input
let result = resolved_program.clone().enforce_main_function(
let result = resolved_program.enforce_main_function(
cs,
program_name.clone(),
&program_name,
test.function,
input, // pass program input into every test
);
@ -147,7 +147,7 @@ pub fn generate_test_constraints<F: Field + PrimeField, G: GroupType<F>>(
(false, _) => {
// Set file location of error
let mut error = result.unwrap_err();
error.set_path(main_file_path.clone());
error.set_path(main_file_path);
tracing::error!("{} failed due to error\n\n{}\n", full_test_name, error);

6
compiler/src/definition/definition.rs
View File

@ -28,17 +28,17 @@ use snarkos_models::curves::{Field, PrimeField};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn store_definition(
&mut self,
function_scope: String,
function_scope: &str,
mutable: bool,
identifier: Identifier,
mut value: ConstrainedValue<F, G>,
) -> () {
) {
// Store with given mutability
if mutable {
value = ConstrainedValue::Mutable(Box::new(value));
}
let variable_program_identifier = new_scope(function_scope, identifier.name);
let variable_program_identifier = new_scope(function_scope, &identifier.name);
self.store(variable_program_identifier, value);
}

6
compiler/src/definition/definitions.rs
View File

@ -35,18 +35,18 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
program
.imports
.iter()
.map(|import| self.store_import(program_name.to_owned(), import, imported_programs))
.map(|import| self.store_import(&program_name, import, imported_programs))
.collect::<Result<Vec<_>, ImportError>>()?;
// evaluate and store all circuit definitions
program.circuits.into_iter().for_each(|(identifier, circuit)| {
let resolved_circuit_name = new_scope(program_name.to_owned(), identifier.to_string());
let resolved_circuit_name = new_scope(program_name, &identifier.name);
self.store(resolved_circuit_name, ConstrainedValue::CircuitDefinition(circuit));
});
// evaluate and store all function definitions
program.functions.into_iter().for_each(|(function_name, function)| {
let resolved_function_name = new_scope(program_name.to_owned(), function_name.to_string());
let resolved_function_name = new_scope(program_name, &function_name.name);
self.store(resolved_function_name, ConstrainedValue::Function(None, function));
});

4
compiler/src/errors/compiler.rs
View File

@ -20,7 +20,7 @@ use leo_input::InputParserError;
use leo_state::LocalDataVerificationError;
use bincode::Error as SerdeError;
use std::path::PathBuf;
use std::path::{Path, PathBuf};
#[derive(Debug, Error)]
pub enum CompilerError {
@ -65,7 +65,7 @@ pub enum CompilerError {
}
impl CompilerError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
CompilerError::InputParserError(error) => error.set_path(path),
CompilerError::FunctionError(error) => error.set_path(path),

7
compiler/src/errors/console.rs
View File

@ -17,7 +17,7 @@
use crate::errors::ExpressionError;
use leo_typed::{Error as FormattedError, Span};
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum ConsoleError {
@ -29,7 +29,7 @@ pub enum ConsoleError {
}
impl ConsoleError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
ConsoleError::Expression(error) => error.set_path(path),
ConsoleError::Error(error) => error.set_path(path),
@ -50,7 +50,8 @@ impl ConsoleError {
}
pub fn assertion_depends_on_input(span: Span) -> Self {
let message = format!("console.assert() failed to evaluate. This error is caused by empty input file values");
let message =
"console.assert() failed to evaluate. This error is caused by empty input file values".to_string();
Self::new_from_span(message, span)
}

6
compiler/src/errors/expression.rs
View File

@ -19,7 +19,7 @@ use leo_core::LeoCoreError;
use leo_typed::{Error as FormattedError, Identifier, Span};
use snarkos_errors::gadgets::SynthesisError;
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum ExpressionError {
@ -52,7 +52,7 @@ pub enum ExpressionError {
}
impl ExpressionError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
ExpressionError::AddressError(error) => error.set_path(path),
ExpressionError::BooleanError(error) => error.set_path(path),
@ -146,7 +146,7 @@ impl ExpressionError {
}
pub fn self_keyword(span: Span) -> Self {
let message = format!("cannot call keyword `Self` outside of a circuit function");
let message = "cannot call keyword `Self` outside of a circuit function".to_string();
Self::new_from_span(message, span)
}

4
compiler/src/errors/function.rs
View File

@ -27,7 +27,7 @@ use crate::errors::{
};
use leo_typed::{Error as FormattedError, Span};
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum FunctionError {
@ -63,7 +63,7 @@ pub enum FunctionError {
}
impl FunctionError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
FunctionError::AddressError(error) => error.set_path(path),
FunctionError::BooleanError(error) => error.set_path(path),

10
compiler/src/errors/import.rs
View File

@ -18,7 +18,7 @@ use leo_ast::ParserError;
use leo_typed::{Error as FormattedError, Identifier, ImportSymbol, Span};
use leo_core::LeoCoreError;
use std::{io, path::PathBuf};
use std::{io, path::Path};
#[derive(Debug, Error)]
pub enum ImportError {
@ -37,7 +37,7 @@ impl ImportError {
ImportError::Error(FormattedError::new_from_span(message, span))
}
fn new_from_span_with_path(message: String, span: Span, path: PathBuf) -> Self {
fn new_from_span_with_path(message: String, span: Span, path: &Path) -> Self {
ImportError::Error(FormattedError::new_from_span_with_path(message, span, path))
}
@ -48,7 +48,7 @@ impl ImportError {
}
pub fn convert_os_string(span: Span) -> Self {
let message = format!("failed to convert file string name, maybe an illegal character?");
let message = "failed to convert file string name, maybe an illegal character?".to_string();
Self::new_from_span(message, span)
}
@ -65,13 +65,13 @@ impl ImportError {
Self::new_from_span(message, span)
}
pub fn directory_error(error: io::Error, span: Span, path: PathBuf) -> Self {
pub fn directory_error(error: io::Error, span: Span, path: &Path) -> Self {
let message = format!("compilation failed due to directory error - {:?}", error);
Self::new_from_span_with_path(message, span, path)
}
pub fn star(path: PathBuf, span: Span) -> Self {
pub fn star(path: &Path, span: Span) -> Self {
let message = format!("cannot import `*` from path `{:?}`", path);
Self::new_from_span(message, span)

6
compiler/src/errors/output_bytes.rs
View File

@ -16,7 +16,7 @@
use leo_typed::{Error as FormattedError, Span};
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum OutputBytesError {
@ -25,7 +25,7 @@ pub enum OutputBytesError {
}
impl OutputBytesError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
OutputBytesError::Error(error) => error.set_path(path),
}
@ -36,7 +36,7 @@ impl OutputBytesError {
}
pub fn not_enough_registers(span: Span) -> Self {
let message = format!("number of input registers must be greater than or equal to output registers");
let message = "number of input registers must be greater than or equal to output registers".to_string();
Self::new_from_span(message, span)
}

2
compiler/src/errors/output_file.rs
View File

@ -36,6 +36,6 @@ pub enum OutputFileError {
impl From<std::io::Error> for OutputFileError {
fn from(error: std::io::Error) -> Self {
OutputFileError::Crate("std::io", format!("{}", error))
OutputFileError::Crate("std::io", error.to_string())
}
}

10
compiler/src/errors/statement.rs
View File

@ -17,7 +17,7 @@
use crate::errors::{AddressError, BooleanError, ConsoleError, ExpressionError, IntegerError, ValueError};
use leo_typed::{Error as FormattedError, Span, Type};
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum StatementError {
@ -44,7 +44,7 @@ pub enum StatementError {
}
impl StatementError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
StatementError::AddressError(error) => error.set_path(path),
StatementError::BooleanError(error) => error.set_path(path),
@ -67,13 +67,13 @@ impl StatementError {
}
pub fn array_assign_index(span: Span) -> Self {
let message = format!("Cannot assign single index to array of values");
let message = "Cannot assign single index to array of values".to_string();
Self::new_from_span(message, span)
}
pub fn array_assign_range(span: Span) -> Self {
let message = format!("Cannot assign range of array values to single value");
let message = "Cannot assign range of array values to single value".to_string();
Self::new_from_span(message, span)
}
@ -145,7 +145,7 @@ impl StatementError {
}
pub fn tuple_assign_index(span: Span) -> Self {
let message = format!("Cannot assign single index to tuple of values");
let message = "Cannot assign single index to tuple of values".to_string();
Self::new_from_span(message, span)
}

6
compiler/src/errors/value/address.rs
View File

@ -17,7 +17,7 @@
use leo_typed::{Error as FormattedError, Span};
use snarkos_errors::{gadgets::SynthesisError, objects::account::AccountError};
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum AddressError {
@ -26,7 +26,7 @@ pub enum AddressError {
}
impl AddressError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
AddressError::Error(error) => error.set_path(path),
}
@ -64,7 +64,7 @@ impl AddressError {
}
pub fn missing_address(span: Span) -> Self {
let message = format!("expected address input not found");
let message = "expected address input not found".to_string();
Self::new_from_span(message, span)
}

4
compiler/src/errors/value/boolean.rs
View File

@ -17,7 +17,7 @@
use leo_typed::{Error as FormattedError, Span};
use snarkos_errors::gadgets::SynthesisError;
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum BooleanError {
@ -26,7 +26,7 @@ pub enum BooleanError {
}
impl BooleanError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
BooleanError::Error(error) => error.set_path(path),
}

4
compiler/src/errors/value/field.rs
View File

@ -17,7 +17,7 @@
use leo_typed::{Error as FormattedError, Span};
use snarkos_errors::gadgets::SynthesisError;
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum FieldError {
@ -26,7 +26,7 @@ pub enum FieldError {
}
impl FieldError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
FieldError::Error(error) => error.set_path(path),
}

8
compiler/src/errors/value/group.rs
View File

@ -17,7 +17,7 @@
use leo_typed::{Error as FormattedError, Span};
use snarkos_errors::gadgets::SynthesisError;
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum GroupError {
@ -26,7 +26,7 @@ pub enum GroupError {
}
impl GroupError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
GroupError::Error(error) => error.set_path(path),
}
@ -88,13 +88,13 @@ impl GroupError {
}
pub fn x_recover(span: Span) -> Self {
let message = format!("could not recover group element from x coordinate");
let message = "could not recover group element from x coordinate".to_string();
Self::new_from_span(message, span)
}
pub fn y_recover(span: Span) -> Self {
let message = format!("could not recover group element from y coordinate");
let message = "could not recover group element from y coordinate".to_string();
Self::new_from_span(message, span)
}

10
compiler/src/errors/value/integer.rs
View File

@ -18,7 +18,7 @@ use leo_gadgets::errors::SignedIntegerError;
use leo_typed::{error::Error as FormattedError, Span};
use snarkos_errors::gadgets::SynthesisError;
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum IntegerError {
@ -27,7 +27,7 @@ pub enum IntegerError {
}
impl IntegerError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
IntegerError::Error(error) => error.set_path(path),
}
@ -68,7 +68,7 @@ impl IntegerError {
}
pub fn negate_operation(span: Span) -> Self {
let message = format!("integer negation can only be enforced on signed integers");
let message = "integer negation can only be enforced on signed integers".to_string();
Self::new_from_span(message, span)
}
@ -83,9 +83,9 @@ impl IntegerError {
}
pub fn invalid_index(span: Span) -> Self {
let message = format!(
let message =
"index must be a constant value unsigned integer. allocated indices produce a circuit of unknown size"
);
.to_string();
Self::new_from_span(message, span)
}

6
compiler/src/errors/value/value.rs
View File

@ -17,7 +17,7 @@
use crate::errors::{AddressError, BooleanError, FieldError, GroupError, IntegerError};
use leo_typed::{Error as FormattedError, Span};
use std::path::PathBuf;
use std::path::Path;
#[derive(Debug, Error)]
pub enum ValueError {
@ -41,7 +41,7 @@ pub enum ValueError {
}
impl ValueError {
pub fn set_path(&mut self, path: PathBuf) {
pub fn set_path(&mut self, path: &Path) {
match self {
ValueError::AddressError(error) => error.set_path(path),
ValueError::BooleanError(error) => error.set_path(path),
@ -63,7 +63,7 @@ impl ValueError {
}
pub fn implicit_group(span: Span) -> Self {
let message = format!("group coordinates should be in (x, y)group format");
let message = "group coordinates should be in (x, y)group format".to_string();
Self::new_from_span(message, span)
}

8
compiler/src/expression/arithmetic/add.rs
View File

@ -28,7 +28,7 @@ pub fn enforce_add<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
match (left, right) {
(ConstrainedValue::Integer(num_1), ConstrainedValue::Integer(num_2)) => {
@ -41,16 +41,16 @@ pub fn enforce_add<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
Ok(ConstrainedValue::Group(point_1.add(cs, &point_2, span)?))
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
enforce_add(cs, val_1, val_2, span)
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
enforce_add(cs, val_1, val_2, span)
}
(val_1, val_2) => Err(ExpressionError::incompatible_types(
format!("{} + {}", val_1, val_2),
span,
span.to_owned(),
)),
}
}

16
compiler/src/expression/arithmetic/div.rs
View File

@ -28,7 +28,7 @@ pub fn enforce_div<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
match (left, right) {
(ConstrainedValue::Integer(num_1), ConstrainedValue::Integer(num_2)) => {
@ -38,18 +38,16 @@ pub fn enforce_div<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
Ok(ConstrainedValue::Field(field_1.div(cs, &field_2, span)?))
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
enforce_div(cs, val_1, val_2, span)
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
enforce_div(cs, val_1, val_2, span)
}
(val_1, val_2) => {
return Err(ExpressionError::incompatible_types(
format!("{} / {}", val_1, val_2,),
span,
));
}
(val_1, val_2) => Err(ExpressionError::incompatible_types(
format!("{} / {}", val_1, val_2,),
span.to_owned(),
)),
}
}

16
compiler/src/expression/arithmetic/mul.rs
View File

@ -28,7 +28,7 @@ pub fn enforce_mul<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
match (left, right) {
(ConstrainedValue::Integer(num_1), ConstrainedValue::Integer(num_2)) => {
@ -38,18 +38,16 @@ pub fn enforce_mul<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
Ok(ConstrainedValue::Field(field_1.mul(cs, &field_2, span)?))
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
enforce_mul(cs, val_1, val_2, span)
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
enforce_mul(cs, val_1, val_2, span)
}
(val_1, val_2) => {
return Err(ExpressionError::incompatible_types(
format!("{} * {}", val_1, val_2),
span,
));
}
(val_1, val_2) => Err(ExpressionError::incompatible_types(
format!("{} * {}", val_1, val_2),
span.to_owned(),
)),
}
}

7
compiler/src/expression/arithmetic/negate.rs
View File

@ -27,12 +27,15 @@ use snarkos_models::{
pub fn enforce_negate<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<F>>(
cs: &mut CS,
value: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
match value {
ConstrainedValue::Integer(integer) => Ok(ConstrainedValue::Integer(integer.negate(cs, span)?)),
ConstrainedValue::Field(field) => Ok(ConstrainedValue::Field(field.negate(cs, span)?)),
ConstrainedValue::Group(group) => Ok(ConstrainedValue::Group(group.negate(cs, span)?)),
value => Err(ExpressionError::incompatible_types(format!("-{}", value), span)),
value => Err(ExpressionError::incompatible_types(
format!("-{}", value),
span.to_owned(),
)),
}
}

8
compiler/src/expression/arithmetic/pow.rs
View File

@ -28,23 +28,23 @@ pub fn enforce_pow<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
match (left, right) {
(ConstrainedValue::Integer(num_1), ConstrainedValue::Integer(num_2)) => {
Ok(ConstrainedValue::Integer(num_1.pow(cs, num_2, span)?))
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
enforce_pow(cs, val_1, val_2, span)
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
enforce_pow(cs, val_1, val_2, span)
}
(val_1, val_2) => Err(ExpressionError::incompatible_types(
format!("{} ** {}", val_1, val_2,),
span,
span.to_owned(),
)),
}
}

8
compiler/src/expression/arithmetic/sub.rs
View File

@ -28,7 +28,7 @@ pub fn enforce_sub<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
match (left, right) {
(ConstrainedValue::Integer(num_1), ConstrainedValue::Integer(num_2)) => {
@ -41,16 +41,16 @@ pub fn enforce_sub<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
Ok(ConstrainedValue::Group(point_1.sub(cs, &point_2, span)?))
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, &span)?;
enforce_sub(cs, val_1, val_2, span)
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, &span)?;
enforce_sub(cs, val_1, val_2, span)
}
(val_1, val_2) => Err(ExpressionError::incompatible_types(
format!("{} - {}", val_1, val_2),
span,
span.to_owned(),
)),
}
}

23
compiler/src/expression/array/access.rs
View File

@ -25,40 +25,37 @@ use snarkos_models::{
};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
#[allow(clippy::too_many_arguments)]
pub fn enforce_array_access<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
array: Box<Expression>,
array: Expression,
index: RangeOrExpression,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let array = match self.enforce_operand(
cs,
file_scope.clone(),
function_scope.clone(),
expected_type,
*array,
span.clone(),
array,
span,
)? {
ConstrainedValue::Array(array) => array,
value => return Err(ExpressionError::undefined_array(value.to_string(), span)),
value => return Err(ExpressionError::undefined_array(value.to_string(), span.to_owned())),
};
match index {
RangeOrExpression::Range(from, to) => {
let from_resolved = match from {
Some(from_index) => {
self.enforce_index(cs, file_scope.clone(), function_scope.clone(), from_index, span.clone())?
}
Some(from_index) => self.enforce_index(cs, file_scope, function_scope, from_index, span)?,
None => 0usize, // Array slice starts at index 0
};
let to_resolved = match to {
Some(to_index) => {
self.enforce_index(cs, file_scope.clone(), function_scope.clone(), to_index, span.clone())?
}
Some(to_index) => self.enforce_index(cs, file_scope, function_scope, to_index, span)?,
None => array.len(), // Array slice ends at array length
};
Ok(ConstrainedValue::Array(array[from_resolved..to_resolved].to_owned()))

32
compiler/src/expression/array/array.rs
View File

@ -34,10 +34,10 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn enforce_array<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
mut expected_type: Option<Type>,
array: Vec<Box<SpreadOrExpression>>,
array: Vec<SpreadOrExpression>,
span: Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
// Check explicit array type dimension if given
@ -47,12 +47,12 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
match type_ {
Type::Array(ref type_, ref dimensions) => {
let number = match dimensions.first() {
Some(number) => number.clone(),
Some(number) => *number,
None => return Err(ExpressionError::unexpected_array(type_.to_string(), span)),
};
expected_dimensions.push(number);
expected_type = Some(type_.outer_dimension(dimensions).clone());
expected_type = Some(type_.outer_dimension(dimensions));
}
ref type_ => {
return Err(ExpressionError::unexpected_array(type_.to_string(), span));
@ -62,10 +62,10 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let mut result = vec![];
for element in array.into_iter() {
match *element {
match element {
SpreadOrExpression::Spread(spread) => match spread {
Expression::Identifier(identifier) => {
let array_name = new_scope(function_scope.clone(), identifier.to_string());
let array_name = new_scope(&function_scope, &identifier.name);
match self.get(&array_name) {
Some(value) => match value {
ConstrainedValue::Array(array) => result.extend(array.clone()),
@ -79,8 +79,8 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
SpreadOrExpression::Expression(expression) => {
result.push(self.enforce_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type.clone(),
expression,
)?);
@ -89,14 +89,12 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
}
// Check expected_dimensions if given
if !expected_dimensions.is_empty() {
if expected_dimensions[expected_dimensions.len() - 1] != result.len() {
return Err(ExpressionError::invalid_length(
expected_dimensions[expected_dimensions.len() - 1],
result.len(),
span,
));
}
if !expected_dimensions.is_empty() && expected_dimensions[expected_dimensions.len() - 1] != result.len() {
return Err(ExpressionError::invalid_length(
expected_dimensions[expected_dimensions.len() - 1],
result.len(),
span,
));
}
Ok(ConstrainedValue::Array(result))

19
compiler/src/expression/array/index.rs
View File

@ -28,22 +28,15 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub(crate) fn enforce_index<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
index: Expression,
span: Span,
span: &Span,
) -> Result<usize, ExpressionError> {
let expected_type = Some(Type::IntegerType(IntegerType::U32));
match self.enforce_operand(
cs,
file_scope.clone(),
function_scope.clone(),
expected_type,
index,
span.clone(),
)? {
ConstrainedValue::Integer(number) => Ok(number.to_usize(span.clone())?),
value => Err(ExpressionError::invalid_index(value.to_string(), span)),
match self.enforce_operand(cs, file_scope, function_scope, expected_type, index, &span)? {
ConstrainedValue::Integer(number) => Ok(number.to_usize(span)?),
value => Err(ExpressionError::invalid_index(value.to_string(), span.to_owned())),
}
}
}

31
compiler/src/expression/binary/binary.rs
View File

@ -24,33 +24,24 @@ use snarkos_models::{
gadgets::r1cs::ConstraintSystem,
};
type ConstrainedValuePair<T, U> = (ConstrainedValue<T, U>, ConstrainedValue<T, U>);
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
#[allow(clippy::too_many_arguments)]
pub fn enforce_binary_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
left: Expression,
right: Expression,
span: Span,
) -> Result<(ConstrainedValue<F, G>, ConstrainedValue<F, G>), ExpressionError> {
let mut resolved_left = self.enforce_operand(
cs,
file_scope.clone(),
function_scope.clone(),
expected_type.clone(),
left,
span.clone(),
)?;
let mut resolved_right = self.enforce_operand(
cs,
file_scope.clone(),
function_scope.clone(),
expected_type.clone(),
right,
span.clone(),
)?;
span: &Span,
) -> Result<ConstrainedValuePair<F, G>, ExpressionError> {
let mut resolved_left =
self.enforce_operand(cs, file_scope, function_scope, expected_type.clone(), left, span)?;
let mut resolved_right =
self.enforce_operand(cs, file_scope, function_scope, expected_type.clone(), right, span)?;
resolved_left.resolve_types(&mut resolved_right, expected_type, span)?;

6
compiler/src/expression/binary/operand.rs
View File

@ -31,11 +31,11 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn enforce_operand<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
expression: Expression,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let mut branch = self.enforce_expression(cs, file_scope, function_scope, expected_type.clone(), expression)?;

27
compiler/src/expression/circuit/access.rs
View File

@ -29,14 +29,15 @@ use snarkos_models::{
gadgets::r1cs::ConstraintSystem,
};
static SELF_KEYWORD: &'static str = "self";
static SELF_KEYWORD: &str = "self";
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
#[allow(clippy::too_many_arguments)]
pub fn enforce_circuit_access<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
circuit_identifier: Box<Expression>,
circuit_member: Identifier,
@ -45,11 +46,11 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// access a circuit member using the `self` keyword
if let Expression::Identifier(ref identifier) = *circuit_identifier {
if identifier.is_self() {
let self_file_scope = new_scope(file_scope.clone(), identifier.name.to_string());
let self_function_scope = new_scope(self_file_scope.clone(), identifier.name.to_string());
let self_file_scope = new_scope(&file_scope, &identifier.name);
let self_function_scope = new_scope(&self_file_scope, &identifier.name);
let member_value =
self.evaluate_identifier(self_file_scope, self_function_scope, None, circuit_member.clone())?;
self.evaluate_identifier(&self_file_scope, &self_function_scope, None, circuit_member)?;
return Ok(member_value);
}
@ -57,11 +58,11 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let (circuit_name, members) = match self.enforce_operand(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
*circuit_identifier.clone(),
span.clone(),
*circuit_identifier,
&span,
)? {
ConstrainedValue::CircuitExpression(name, members) => (name, members),
value => return Err(ExpressionError::undefined_circuit(value.to_string(), span)),
@ -75,9 +76,9 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
ConstrainedValue::Function(ref _circuit_identifier, ref _function) => {
// Pass circuit members into function call by value
for stored_member in members {
let circuit_scope = new_scope(file_scope.clone(), circuit_name.to_string());
let self_keyword = new_scope(circuit_scope, SELF_KEYWORD.to_string());
let variable = new_scope(self_keyword, stored_member.0.to_string());
let circuit_scope = new_scope(&file_scope, &circuit_name.name);
let self_keyword = new_scope(&circuit_scope, SELF_KEYWORD);
let variable = new_scope(&self_keyword, &stored_member.0.name);
self.store(variable, stored_member.1.clone());
}

23
compiler/src/expression/circuit/circuit.rs
View File

@ -33,29 +33,30 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn enforce_circuit<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
identifier: Identifier,
members: Vec<CircuitVariableDefinition>,
span: Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
// Circuit definitions are located at the minimum file scope
let scopes: Vec<&str> = file_scope.split("_").collect();
let mut program_identifier = new_scope(scopes[0].to_string(), identifier.to_string());
let minimum_scope = file_scope.split('_').next().unwrap();
let identifier_string = identifier.to_string();
let mut program_identifier = new_scope(minimum_scope, &identifier_string);
if identifier.is_self() {
program_identifier = file_scope.clone();
program_identifier = file_scope.to_string();
}
let circuit = match self.get(&program_identifier) {
Some(value) => value.clone().extract_circuit(span.clone())?,
Some(value) => value.clone().extract_circuit(&span)?,
None => return Err(ExpressionError::undefined_circuit(identifier.to_string(), span)),
};
let circuit_identifier = circuit.circuit_name.clone();
let mut resolved_members = vec![];
let mut resolved_members = Vec::with_capacity(circuit.members.len());
for member in circuit.members.clone().into_iter() {
for member in circuit.members.into_iter() {
match member {
CircuitMember::CircuitVariable(is_mutable, identifier, type_) => {
let matched_variable = members
@ -67,8 +68,8 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Resolve and enforce circuit variable
let mut variable_value = self.enforce_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
Some(type_.clone()),
variable.expression,
)?;
@ -98,7 +99,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
}
Ok(ConstrainedValue::CircuitExpression(
circuit_identifier.clone(),
circuit_identifier,
resolved_members,
))
}

21
compiler/src/expression/circuit/static_access.rs
View File

@ -25,39 +25,34 @@ use snarkos_models::{
};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
#[allow(clippy::too_many_arguments)]
pub fn enforce_circuit_static_access<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
circuit_identifier: Box<Expression>,
circuit_member: Identifier,
span: Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
// Get defined circuit
let circuit = match *circuit_identifier.clone() {
let circuit = match *circuit_identifier {
Expression::Identifier(identifier) => {
// Use the "Self" keyword to access a static circuit function
if identifier.is_self() {
let circuit = self
.get(&file_scope)
.ok_or(ExpressionError::self_keyword(identifier.span.clone()))?;
.ok_or_else(|| ExpressionError::self_keyword(identifier.span))?;
circuit.to_owned()
} else {
self.evaluate_identifier(file_scope.clone(), function_scope.clone(), expected_type, identifier)?
self.evaluate_identifier(&file_scope, &function_scope, expected_type, identifier)?
}
}
expression => self.enforce_expression(
cs,
file_scope.clone(),
function_scope.clone(),
expected_type,
expression,
)?,
expression => self.enforce_expression(cs, file_scope, function_scope, expected_type, expression)?,
}
.extract_circuit(span.clone())?;
.extract_circuit(&span)?;
// Find static circuit function
let matched_function = circuit.members.into_iter().find(|member| match member {

42
compiler/src/expression/conditional/conditional.rs
View File

@ -26,45 +26,27 @@ use snarkos_models::{
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
/// Enforce ternary conditional expression
#[allow(clippy::too_many_arguments)]
pub fn enforce_conditional_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
conditional: Expression,
first: Expression,
second: Expression,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let conditional_value = match self.enforce_expression(
cs,
file_scope.clone(),
function_scope.clone(),
Some(Type::Boolean),
conditional,
)? {
ConstrainedValue::Boolean(resolved) => resolved,
value => return Err(ExpressionError::conditional_boolean(value.to_string(), span)),
};
let conditional_value =
match self.enforce_expression(cs, file_scope, function_scope, Some(Type::Boolean), conditional)? {
ConstrainedValue::Boolean(resolved) => resolved,
value => return Err(ExpressionError::conditional_boolean(value.to_string(), span.to_owned())),
};
let first_value = self.enforce_operand(
cs,
file_scope.clone(),
function_scope.clone(),
expected_type.clone(),
first,
span.clone(),
)?;
let first_value = self.enforce_operand(cs, file_scope, function_scope, expected_type.clone(), first, span)?;
let second_value = self.enforce_operand(
cs,
file_scope.clone(),
function_scope.clone(),
expected_type,
second,
span.clone(),
)?;
let second_value = self.enforce_operand(cs, file_scope, function_scope, expected_type, second, span)?;
let unique_namespace = cs.ns(|| {
format!(
@ -74,6 +56,6 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
});
ConstrainedValue::conditionally_select(unique_namespace, &conditional_value, &first_value, &second_value)
.map_err(|e| ExpressionError::cannot_enforce(format!("conditional select"), e, span))
.map_err(|e| ExpressionError::cannot_enforce("conditional select".to_string(), e, span.to_owned()))
}
}

214
compiler/src/expression/expression.rs
View File

@ -39,8 +39,8 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub(crate) fn enforce_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
expression: Expression,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
@ -51,86 +51,86 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
}
// Values
Expression::Address(address, span) => Ok(ConstrainedValue::Address(Address::constant(address, span)?)),
Expression::Boolean(boolean, span) => Ok(ConstrainedValue::Boolean(new_bool_constant(boolean, span)?)),
Expression::Field(field, span) => Ok(ConstrainedValue::Field(FieldType::constant(field, span)?)),
Expression::Group(group_element) => Ok(ConstrainedValue::Group(G::constant(group_element)?)),
Expression::Implicit(value, span) => Ok(enforce_number_implicit(expected_type, value, span)?),
Expression::Integer(type_, integer, span) => {
Ok(ConstrainedValue::Integer(Integer::new_constant(&type_, integer, span)?))
}
Expression::Address(address, span) => Ok(ConstrainedValue::Address(Address::constant(address, &span)?)),
Expression::Boolean(boolean, span) => Ok(ConstrainedValue::Boolean(new_bool_constant(boolean, &span)?)),
Expression::Field(field, span) => Ok(ConstrainedValue::Field(FieldType::constant(field, &span)?)),
Expression::Group(group_element) => Ok(ConstrainedValue::Group(G::constant(*group_element)?)),
Expression::Implicit(value, span) => Ok(enforce_number_implicit(expected_type, value, &span)?),
Expression::Integer(type_, integer, span) => Ok(ConstrainedValue::Integer(Integer::new_constant(
&type_, integer, &span,
)?)),
// Binary operations
Expression::Negate(expression, span) => {
let resolved_value =
self.enforce_expression(cs, file_scope, function_scope, expected_type, *expression)?;
enforce_negate(cs, resolved_value, span)
enforce_negate(cs, resolved_value, &span)
}
Expression::Add(left, right, span) => {
Expression::Add(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
enforce_add(cs, resolved_left, resolved_right, span)
enforce_add(cs, resolved_left, resolved_right, &span)
}
Expression::Sub(left, right, span) => {
Expression::Sub(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
enforce_sub(cs, resolved_left, resolved_right, span)
enforce_sub(cs, resolved_left, resolved_right, &span)
}
Expression::Mul(left, right, span) => {
Expression::Mul(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
enforce_mul(cs, resolved_left, resolved_right, span)
enforce_mul(cs, resolved_left, resolved_right, &span)
}
Expression::Div(left, right, span) => {
Expression::Div(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
enforce_div(cs, resolved_left, resolved_right, span)
enforce_div(cs, resolved_left, resolved_right, &span)
}
Expression::Pow(left, right, span) => {
Expression::Pow(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
enforce_pow(cs, resolved_left, resolved_right, span)
enforce_pow(cs, resolved_left, resolved_right, &span)
}
// Boolean operations
@ -138,124 +138,130 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
self.enforce_expression(cs, file_scope, function_scope, expected_type, *expression)?,
span,
)?),
Expression::Or(left, right, span) => {
Expression::Or(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
Ok(enforce_or(cs, resolved_left, resolved_right, span)?)
Ok(enforce_or(cs, resolved_left, resolved_right, &span)?)
}
Expression::And(left, right, span) => {
Expression::And(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
Ok(enforce_and(cs, resolved_left, resolved_right, span)?)
Ok(enforce_and(cs, resolved_left, resolved_right, &span)?)
}
Expression::Eq(left, right, span) => {
Expression::Eq(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
None,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
Ok(evaluate_eq(cs, resolved_left, resolved_right, span)?)
Ok(evaluate_eq(cs, resolved_left, resolved_right, &span)?)
}
Expression::Ge(left, right, span) => {
Expression::Ge(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
None,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
Ok(evaluate_ge(cs, resolved_left, resolved_right, span)?)
Ok(evaluate_ge(cs, resolved_left, resolved_right, &span)?)
}
Expression::Gt(left, right, span) => {
Expression::Gt(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
None,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
Ok(evaluate_gt(cs, resolved_left, resolved_right, span)?)
Ok(evaluate_gt(cs, resolved_left, resolved_right, &span)?)
}
Expression::Le(left, right, span) => {
Expression::Le(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
None,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
Ok(evaluate_le(cs, resolved_left, resolved_right, span)?)
Ok(evaluate_le(cs, resolved_left, resolved_right, &span)?)
}
Expression::Lt(left, right, span) => {
Expression::Lt(left_right, span) => {
let (resolved_left, resolved_right) = self.enforce_binary_expression(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
None,
*left,
*right,
span.clone(),
left_right.0,
left_right.1,
&span,
)?;
Ok(evaluate_lt(cs, resolved_left, resolved_right, span)?)
Ok(evaluate_lt(cs, resolved_left, resolved_right, &span)?)
}
// Conditionals
Expression::IfElse(conditional, first, second, span) => self.enforce_conditional_expression(
Expression::IfElse(triplet, span) => self.enforce_conditional_expression(
cs,
file_scope,
function_scope,
expected_type,
*conditional,
*first,
*second,
span,
triplet.0,
triplet.1,
triplet.2,
&span,
),
// Arrays
Expression::Array(array, span) => {
self.enforce_array(cs, file_scope, function_scope, expected_type, array, span)
}
Expression::ArrayAccess(array, index, span) => {
self.enforce_array_access(cs, file_scope, function_scope, expected_type, array, *index, span)
}
Expression::ArrayAccess(array_w_index, span) => self.enforce_array_access(
cs,
file_scope,
function_scope,
expected_type,
array_w_index.0,
array_w_index.1,
&span,
),
// Tuples
Expression::Tuple(tuple, span) => {
self.enforce_tuple(cs, file_scope, function_scope, expected_type, tuple, span)
}
Expression::TupleAccess(tuple, index, span) => {
self.enforce_tuple_access(cs, file_scope, function_scope, expected_type, tuple, index, span)
self.enforce_tuple_access(cs, file_scope, function_scope, expected_type, tuple, index, &span)
}
// Circuits

19
compiler/src/expression/function/core_circuit.rs
View File

@ -25,21 +25,21 @@ use snarkos_models::{
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
/// Call a default core circuit function with arguments
#[allow(clippy::too_many_arguments)]
pub fn enforce_core_circuit_call_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
core_circuit: String,
arguments: Vec<Expression>,
span: Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
// Get the value of each core function argument
let mut argument_values = vec![];
let mut argument_values = Vec::with_capacity(arguments.len());
for argument in arguments.into_iter() {
let argument_value =
self.enforce_expression(cs, file_scope.clone(), function_scope.clone(), None, argument)?;
let argument_value = self.enforce_expression(cs, file_scope, function_scope, None, argument)?;
let core_function_argument = argument_value.to_value();
argument_values.push(core_function_argument);
@ -49,10 +49,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let res = call_core_circuit(cs, core_circuit, argument_values, span.clone())?;
// Convert the core function returns into constrained values
let returns = res
.into_iter()
.map(|value| ConstrainedValue::from(value))
.collect::<Vec<_>>();
let returns = res.into_iter().map(ConstrainedValue::from).collect::<Vec<_>>();
let return_value = if returns.len() == 1 {
// The function has a single return
@ -64,7 +61,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Check that function returns expected type
if let Some(expected) = expected_type {
let actual = return_value.to_type(span.clone())?;
let actual = return_value.to_type(&span)?;
if expected.ne(&actual) {
return Err(ExpressionError::FunctionError(Box::new(
FunctionError::return_argument_type(expected.to_string(), actual.to_string(), span),
@ -72,6 +69,6 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
}
}
return Ok(return_value);
Ok(return_value)
}
}

25
compiler/src/expression/function/function.rs
View File

@ -25,30 +25,31 @@ use snarkos_models::{
};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
#[allow(clippy::too_many_arguments)]
pub fn enforce_function_call_expression<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
function: Box<Expression>,
arguments: Vec<Expression>,
span: Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let (declared_circuit_reference, function_value) = match *function.clone() {
let (declared_circuit_reference, function_value) = match *function {
Expression::CircuitMemberAccess(circuit_identifier, circuit_member, span) => {
// Call a circuit function that can mutate self.
// Save a reference to the circuit we are mutating.
let circuit_id_string = format!("{}", circuit_identifier);
let declared_circuit_reference = new_scope(function_scope.clone(), circuit_id_string);
let circuit_id_string = circuit_identifier.to_string();
let declared_circuit_reference = new_scope(function_scope.clone(), &circuit_id_string);
(
declared_circuit_reference,
self.enforce_circuit_access(
cs,
file_scope.clone(),
function_scope.clone(),
file_scope,
function_scope,
expected_type,
circuit_identifier,
circuit_member,
@ -57,12 +58,12 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
)
}
function => (
function_scope.clone(),
self.enforce_expression(cs, file_scope.clone(), function_scope.clone(), expected_type, function)?,
function_scope.to_string(),
self.enforce_expression(cs, file_scope, function_scope, expected_type, function)?,
),
};
let (outer_scope, function_call) = function_value.extract_function(file_scope.clone(), span.clone())?;
let (outer_scope, function_call) = function_value.extract_function(file_scope, &span)?;
let name_unique = format!(
"function call {} {}:{}",
@ -73,11 +74,11 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
self.enforce_function(
&mut cs.ns(|| name_unique),
outer_scope,
&outer_scope,
function_scope,
function_call,
arguments,
declared_circuit_reference,
&declared_circuit_reference,
)
.map_err(|error| ExpressionError::from(Box::new(error)))
}

12
compiler/src/expression/identifier/identifier.rs
View File

@ -31,14 +31,14 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
/// Enforce a variable expression by getting the resolved value
pub fn evaluate_identifier(
&mut self,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
unresolved_identifier: Identifier,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
// Evaluate the identifier name in the current function scope
let variable_name = new_scope(function_scope.clone(), unresolved_identifier.to_string());
let identifier_name = new_scope(file_scope, unresolved_identifier.to_string());
let variable_name = new_scope(function_scope, &unresolved_identifier.name);
let identifier_name = new_scope(file_scope, &unresolved_identifier.name);
let mut result_value = if let Some(value) = self.get(&variable_name) {
// Reassigning variable to another variable
@ -51,14 +51,14 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
value.clone()
} else if expected_type.is_some() && expected_type.unwrap() == Type::Address {
// If we expect an address type, try to return an address
let address = Address::constant(unresolved_identifier.name, unresolved_identifier.span)?;
let address = Address::constant(unresolved_identifier.name, &unresolved_identifier.span)?;
return Ok(ConstrainedValue::Address(address));
} else {
return Err(ExpressionError::undefined_identifier(unresolved_identifier));
};
result_value.resolve_type(expected_type, unresolved_identifier.span.clone())?;
result_value.resolve_type(expected_type, &unresolved_identifier.span)?;
Ok(result_value)
}

6
compiler/src/expression/logical/and.rs
View File

@ -28,17 +28,17 @@ pub fn enforce_and<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, BooleanError> {
let name = format!("{} && {}", left, right);
if let (ConstrainedValue::Boolean(left_bool), ConstrainedValue::Boolean(right_bool)) = (left, right) {
let name_unique = format!("{} {}:{}", name, span.line, span.start);
let result = Boolean::and(cs.ns(|| name_unique), &left_bool, &right_bool)
.map_err(|e| BooleanError::cannot_enforce(format!("&&"), e, span))?;
.map_err(|e| BooleanError::cannot_enforce("&&".to_string(), e, span.to_owned()))?;
return Ok(ConstrainedValue::Boolean(result));
}
Err(BooleanError::cannot_evaluate(name, span))
Err(BooleanError::cannot_evaluate(name, span.to_owned()))
}

6
compiler/src/expression/logical/or.rs
View File

@ -28,17 +28,17 @@ pub fn enforce_or<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<F
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, BooleanError> {
let name = format!("{} || {}", left, right);
if let (ConstrainedValue::Boolean(left_bool), ConstrainedValue::Boolean(right_bool)) = (left, right) {
let name_unique = format!("{} {}:{}", name, span.line, span.start);
let result = Boolean::or(cs.ns(|| name_unique), &left_bool, &right_bool)
.map_err(|e| BooleanError::cannot_enforce(format!("||"), e, span))?;
.map_err(|e| BooleanError::cannot_enforce("||".to_string(), e, span.to_owned()))?;
return Ok(ConstrainedValue::Boolean(result));
}
Err(BooleanError::cannot_evaluate(name, span))
Err(BooleanError::cannot_evaluate(name, span.to_owned()))
}

28
compiler/src/expression/relational/eq.rs
View File

@ -31,7 +31,7 @@ pub fn evaluate_eq<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let namespace_string = format!("evaluate {} == {} {}:{}", left, right, span.line, span.start);
let constraint_result = match (left, right) {
@ -58,14 +58,9 @@ pub fn evaluate_eq<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
(ConstrainedValue::Array(arr_1), ConstrainedValue::Array(arr_2)) => {
let mut current = ConstrainedValue::Boolean(Boolean::constant(true));
for (i, (left, right)) in arr_1.into_iter().zip(arr_2.into_iter()).enumerate() {
let next = evaluate_eq(&mut cs.ns(|| format!("array[{}]", i)), left, right, span.clone())?;
let next = evaluate_eq(&mut cs.ns(|| format!("array[{}]", i)), left, right, span)?;
current = enforce_and(
&mut cs.ns(|| format!("array result {}", i)),
current,
next,
span.clone(),
)?;
current = enforce_and(&mut cs.ns(|| format!("array result {}", i)), current, next, span)?;
}
return Ok(current);
}
@ -73,36 +68,31 @@ pub fn evaluate_eq<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
let mut current = ConstrainedValue::Boolean(Boolean::constant(true));
for (i, (left, right)) in tuple_1.into_iter().zip(tuple_2.into_iter()).enumerate() {
let next = evaluate_eq(&mut cs.ns(|| format!("tuple_index {}", i)), left, right, span.clone())?;
let next = evaluate_eq(&mut cs.ns(|| format!("tuple_index {}", i)), left, right, span)?;
current = enforce_and(
&mut cs.ns(|| format!("array result {}", i)),
current,
next,
span.clone(),
)?;
current = enforce_and(&mut cs.ns(|| format!("array result {}", i)), current, next, span)?;
}
return Ok(current);
}
(ConstrainedValue::Unresolved(string), val_2) => {
let mut unique_namespace = cs.ns(|| namespace_string);
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
return evaluate_eq(&mut unique_namespace, val_1, val_2, span);
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let mut unique_namespace = cs.ns(|| namespace_string);
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
return evaluate_eq(&mut unique_namespace, val_1, val_2, span);
}
(val_1, val_2) => {
return Err(ExpressionError::incompatible_types(
format!("{} == {}", val_1, val_2,),
span,
span.to_owned(),
));
}
};
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate(format!("=="), span))?;
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate("==".to_string(), span.to_owned()))?;
Ok(ConstrainedValue::Boolean(boolean))
}

10
compiler/src/expression/relational/ge.rs
View File

@ -29,7 +29,7 @@ pub fn evaluate_ge<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let mut unique_namespace = cs.ns(|| format!("evaluate {} >= {} {}:{}", left, right, span.line, span.start));
let constraint_result = match (left, right) {
@ -37,22 +37,22 @@ pub fn evaluate_ge<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
num_1.greater_than_or_equal(unique_namespace, &num_2)
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
return evaluate_ge(&mut unique_namespace, val_1, val_2, span);
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
return evaluate_ge(&mut unique_namespace, val_1, val_2, span);
}
(val_1, val_2) => {
return Err(ExpressionError::incompatible_types(
format!("{} >= {}", val_1, val_2),
span,
span.to_owned(),
));
}
};
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate(format!(">="), span))?;
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate(">=".to_string(), span.to_owned()))?;
Ok(ConstrainedValue::Boolean(boolean))
}

10
compiler/src/expression/relational/gt.rs
View File

@ -29,7 +29,7 @@ pub fn evaluate_gt<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let mut unique_namespace = cs.ns(|| format!("evaluate {} > {} {}:{}", left, right, span.line, span.start));
let constraint_result = match (left, right) {
@ -37,22 +37,22 @@ pub fn evaluate_gt<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
num_1.greater_than(unique_namespace, &num_2)
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
return evaluate_gt(&mut unique_namespace, val_1, val_2, span);
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
return evaluate_gt(&mut unique_namespace, val_1, val_2, span);
}
(val_1, val_2) => {
return Err(ExpressionError::incompatible_types(
format!("{} > {}", val_1, val_2),
span,
span.to_owned(),
));
}
};
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate(format!(">"), span))?;
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate(">".to_string(), span.to_owned()))?;
Ok(ConstrainedValue::Boolean(boolean))
}

10
compiler/src/expression/relational/le.rs
View File

@ -29,7 +29,7 @@ pub fn evaluate_le<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let mut unique_namespace = cs.ns(|| format!("evaluate {} <= {} {}:{}", left, right, span.line, span.start));
let constraint_result = match (left, right) {
@ -37,22 +37,22 @@ pub fn evaluate_le<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
num_1.less_than_or_equal(unique_namespace, &num_2)
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
return evaluate_le(&mut unique_namespace, val_1, val_2, span);
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
return evaluate_le(&mut unique_namespace, val_1, val_2, span);
}
(val_1, val_2) => {
return Err(ExpressionError::incompatible_types(
format!("{} <= {}", val_1, val_2),
span,
span.to_owned(),
));
}
};
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate(format!("<="), span))?;
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate("<=".to_string(), span.to_owned()))?;
Ok(ConstrainedValue::Boolean(boolean))
}

10
compiler/src/expression/relational/lt.rs
View File

@ -29,7 +29,7 @@ pub fn evaluate_lt<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
cs: &mut CS,
left: ConstrainedValue<F, G>,
right: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let mut unique_namespace = cs.ns(|| format!("evaluate {} < {} {}:{}", left, right, span.line, span.start));
let constraint_result = match (left, right) {
@ -37,22 +37,22 @@ pub fn evaluate_lt<F: Field + PrimeField, G: GroupType<F>, CS: ConstraintSystem<
num_1.less_than(unique_namespace, &num_2)
}
(ConstrainedValue::Unresolved(string), val_2) => {
let val_1 = ConstrainedValue::from_other(string, &val_2, span.clone())?;
let val_1 = ConstrainedValue::from_other(string, &val_2, span)?;
return evaluate_lt(&mut unique_namespace, val_1, val_2, span);
}
(val_1, ConstrainedValue::Unresolved(string)) => {
let val_2 = ConstrainedValue::from_other(string, &val_1, span.clone())?;
let val_2 = ConstrainedValue::from_other(string, &val_1, span)?;
return evaluate_lt(&mut unique_namespace, val_1, val_2, span);
}
(val_1, val_2) => {
return Err(ExpressionError::incompatible_types(
format!("{} < {}", val_1, val_2),
span,
span.to_owned(),
));
}
};
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate(format!("<"), span))?;
let boolean = constraint_result.map_err(|_| ExpressionError::cannot_evaluate("<".to_string(), span.to_owned()))?;
Ok(ConstrainedValue::Boolean(boolean))
}

20
compiler/src/expression/tuple/access.rs
View File

@ -25,30 +25,24 @@ use snarkos_models::{
};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
#[allow(clippy::too_many_arguments)]
pub fn enforce_tuple_access<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
tuple: Box<Expression>,
index: usize,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, ExpressionError> {
let tuple = match self.enforce_operand(
cs,
file_scope.clone(),
function_scope.clone(),
expected_type,
*tuple,
span.clone(),
)? {
let tuple = match self.enforce_operand(cs, file_scope, function_scope, expected_type, *tuple, &span)? {
ConstrainedValue::Tuple(tuple) => tuple,
value => return Err(ExpressionError::undefined_array(value.to_string(), span.clone())),
value => return Err(ExpressionError::undefined_array(value.to_string(), span.to_owned())),
};
if index > tuple.len() - 1 {
return Err(ExpressionError::index_out_of_bounds(index, span));
return Err(ExpressionError::index_out_of_bounds(index, span.to_owned()));
}
Ok(tuple[index].to_owned())

31
compiler/src/expression/tuple/tuple.rs
View File

@ -29,8 +29,8 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn enforce_tuple<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
expected_type: Option<Type>,
tuple: Vec<Expression>,
span: Span,
@ -38,22 +38,21 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Check explicit tuple type dimension if given
let mut expected_types = vec![];
if expected_type.is_some() {
match expected_type.unwrap() {
Type::Tuple(ref types) => {
expected_types = types.clone();
}
ref type_ => {
return Err(ExpressionError::unexpected_tuple(
type_.to_string(),
format!("{:?}", tuple),
span,
));
}
match expected_type {
Some(Type::Tuple(ref types)) => {
expected_types = types.clone();
}
Some(ref type_) => {
return Err(ExpressionError::unexpected_tuple(
type_.to_string(),
format!("{:?}", tuple),
span,
));
}
None => {}
}
let mut result = vec![];
let mut result = Vec::with_capacity(tuple.len());
for (i, expression) in tuple.into_iter().enumerate() {
let type_ = if expected_types.is_empty() {
None
@ -61,7 +60,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
Some(expected_types[i].clone())
};
result.push(self.enforce_expression(cs, file_scope.clone(), function_scope.clone(), type_, expression)?);
result.push(self.enforce_expression(cs, file_scope, function_scope, type_, expression)?);
}
Ok(ConstrainedValue::Tuple(result))

46
compiler/src/function/function.rs
View File

@ -30,10 +30,10 @@ use snarkos_models::{
gadgets::r1cs::ConstraintSystem,
};
pub fn check_arguments_length(expected: usize, actual: usize, span: Span) -> Result<(), FunctionError> {
pub fn check_arguments_length(expected: usize, actual: usize, span: &Span) -> Result<(), FunctionError> {
// Make sure we are given the correct number of arguments
if expected != actual {
Err(FunctionError::arguments_length(expected, actual, span))
Err(FunctionError::arguments_length(expected, actual, span.to_owned()))
} else {
Ok(())
}
@ -43,39 +43,33 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub(crate) fn enforce_function<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
scope: String,
caller_scope: String,
scope: &str,
caller_scope: &str,
function: Function,
input: Vec<Expression>,
declared_circuit_reference: String,
declared_circuit_reference: &str,
) -> Result<ConstrainedValue<F, G>, FunctionError> {
let function_name = new_scope(scope.clone(), function.get_name());
let function_name = new_scope(scope, function.get_name());
// Make sure we are given the correct number of input variables
check_arguments_length(function.input.len(), input.len(), function.span.clone())?;
check_arguments_length(function.input.len(), input.len(), &function.span)?;
// Store input values as new variables in resolved program
for (input_model, input_expression) in function.input.clone().iter().zip(input.into_iter()) {
for (input_model, input_expression) in function.input.iter().zip(input.into_iter()) {
let (name, value) = match input_model {
InputVariable::InputKeyword(identifier) => {
let input_value = self.enforce_function_input(
cs,
scope.clone(),
caller_scope.clone(),
function_name.clone(),
None,
input_expression,
)?;
let input_value =
self.enforce_function_input(cs, scope, caller_scope, &function_name, None, input_expression)?;
(identifier.name.clone(), input_value)
(&identifier.name, input_value)
}
InputVariable::FunctionInput(input_model) => {
// First evaluate input expression
let mut input_value = self.enforce_function_input(
cs,
scope.clone(),
caller_scope.clone(),
function_name.clone(),
scope,
caller_scope,
&function_name,
Some(input_model.type_.clone()),
input_expression,
)?;
@ -84,12 +78,12 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
input_value = ConstrainedValue::Mutable(Box::new(input_value))
}
(input_model.identifier.name.clone(), input_value)
(&input_model.identifier.name, input_value)
}
};
// Store input as variable with {function_name}_{input_name}
let input_program_identifier = new_scope(function_name.clone(), name);
let input_program_identifier = new_scope(&function_name, &name);
self.store(input_program_identifier, value);
}
@ -99,12 +93,12 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
for statement in function.statements.iter() {
let mut result = self.enforce_statement(
cs,
scope.clone(),
function_name.clone(),
scope,
&function_name,
None,
statement.clone(),
function.returns.clone(),
declared_circuit_reference.clone(),
declared_circuit_reference,
)?;
results.append(&mut result);
@ -113,7 +107,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Conditionally select a result based on returned indicators
let mut return_values = ConstrainedValue::Tuple(vec![]);
Self::conditionally_select_result(cs, &mut return_values, results, function.span.clone())?;
Self::conditionally_select_result(cs, &mut return_values, results, &function.span)?;
if let ConstrainedValue::Tuple(ref returns) = return_values {
let return_types = match function.returns {

27
compiler/src/function/input/array.rs
View File

@ -34,11 +34,11 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn allocate_array<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
name: String,
name: &str,
array_type: Type,
array_dimensions: Vec<usize>,
input_value: Option<InputValue>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, FunctionError> {
let expected_length = array_dimensions[0];
let mut array_value = vec![];
@ -47,34 +47,33 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
Some(InputValue::Array(arr)) => {
// Allocate each value in the current row
for (i, value) in arr.into_iter().enumerate() {
let value_name = new_scope(name.clone(), i.to_string());
let value_name = new_scope(&name, &i.to_string());
let value_type = array_type.outer_dimension(&array_dimensions);
array_value.push(self.allocate_main_function_input(
cs,
value_type,
value_name,
&value_name,
Some(value),
span.clone(),
span,
)?)
}
}
None => {
// Allocate all row values as none
for i in 0..expected_length {
let value_name = new_scope(name.clone(), i.to_string());
let value_name = new_scope(&name, &i.to_string());
let value_type = array_type.outer_dimension(&array_dimensions);
array_value.push(self.allocate_main_function_input(
cs,
value_type,
value_name,
None,
span.clone(),
)?);
array_value.push(self.allocate_main_function_input(cs, value_type, &value_name, None, span)?);
}
}
_ => return Err(FunctionError::invalid_array(input_value.unwrap().to_string(), span)),
_ => {
return Err(FunctionError::invalid_array(
input_value.unwrap().to_string(),
span.to_owned(),
));
}
}
Ok(ConstrainedValue::Array(array_value))

6
compiler/src/function/input/function_input.rs
View File

@ -29,9 +29,9 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn enforce_function_input<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
scope: String,
caller_scope: String,
function_name: String,
scope: &str,
caller_scope: &str,
function_name: &str,
expected_type: Option<Type>,
input: Expression,
) -> Result<ConstrainedValue<F, G>, FunctionError> {

4
compiler/src/function/input/input_keyword.rs
View File

@ -62,14 +62,14 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Allocate each input variable as a circuit expression
let mut sections = vec![];
let mut sections = Vec::with_capacity(4);
sections.push((registers_name, registers_values));
sections.push((record_name, record_values));
sections.push((state_name, state_values));
sections.push((state_leaf_name, state_leaf_values));
let mut members = vec![];
let mut members = Vec::with_capacity(sections.len());
for (name, values) in sections {
let member_name = name.clone();

6
compiler/src/function/input/input_section.rs
View File

@ -30,7 +30,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
identifier: Identifier,
section: HashMap<Parameter, Option<InputValue>>,
) -> Result<ConstrainedValue<F, G>, FunctionError> {
let mut members = vec![];
let mut members = Vec::with_capacity(section.len());
// Allocate each section definition as a circuit member value
@ -39,9 +39,9 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let member_value = self.allocate_main_function_input(
cs,
parameter.type_,
parameter.variable.name,
&parameter.variable.name,
option,
parameter.span,
&parameter.span,
)?;
let member = ConstrainedCircuitMember(member_name, member_value);

6
compiler/src/function/input/main_function_input.rs
View File

@ -42,9 +42,9 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
&mut self,
cs: &mut CS,
type_: Type,
name: String,
name: &str,
input_option: Option<InputValue>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, FunctionError> {
match type_ {
Type::Address => Ok(Address::from_input(cs, name, input_option, span)?),
@ -59,7 +59,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
span,
)?)),
Type::Array(type_, dimensions) => self.allocate_array(cs, name, *type_, dimensions, input_option, span),
Type::Tuple(types) => self.allocate_tuple(cs, name, types, input_option, span),
Type::Tuple(types) => self.allocate_tuple(cs, &name, types, input_option, span),
_ => unimplemented!("main function input not implemented for type"),
}
}

25
compiler/src/function/input/tuple.rs
View File

@ -34,10 +34,10 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn allocate_tuple<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
name: String,
name: &str,
types: Vec<Type>,
input_value: Option<InputValue>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, FunctionError> {
let mut tuple_values = vec![];
@ -45,26 +45,25 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
Some(InputValue::Tuple(values)) => {
// Allocate each value in the tuple
for (i, (value, type_)) in values.into_iter().zip(types.into_iter()).enumerate() {
let value_name = new_scope(name.clone(), i.to_string());
let value_name = new_scope(name, &i.to_string());
tuple_values.push(self.allocate_main_function_input(
cs,
type_,
value_name,
Some(value),
span.clone(),
)?)
tuple_values.push(self.allocate_main_function_input(cs, type_, &value_name, Some(value), span)?)
}
}
None => {
// Allocate all tuple values as none
for (i, type_) in types.into_iter().enumerate() {
let value_name = new_scope(name.clone(), i.to_string());
let value_name = new_scope(name, &i.to_string());
tuple_values.push(self.allocate_main_function_input(cs, type_, value_name, None, span.clone())?);
tuple_values.push(self.allocate_main_function_input(cs, type_, &value_name, None, span)?);
}
}
_ => return Err(FunctionError::invalid_tuple(input_value.unwrap().to_string(), span)),
_ => {
return Err(FunctionError::invalid_tuple(
input_value.unwrap().to_string(),
span.to_owned(),
));
}
}
Ok(ConstrainedValue::Tuple(tuple_values))

21
compiler/src/function/main_function.rs
View File

@ -34,15 +34,15 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn enforce_main_function<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
scope: String,
scope: &str,
function: Function,
input: Input,
) -> Result<OutputBytes, FunctionError> {
let function_name = new_scope(scope.clone(), function.get_name());
let function_name = new_scope(scope, function.get_name());
let registers = input.get_registers();
// Iterate over main function input variables and allocate new values
let mut input_variables = vec![];
let mut input_variables = Vec::with_capacity(function.input.len());
for input_model in function.input.clone().into_iter() {
let (identifier, value) = match input_model {
InputVariable::InputKeyword(identifier) => {
@ -54,21 +54,16 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let name = input_model.identifier.name.clone();
let input_option = input
.get(&name)
.ok_or(FunctionError::input_not_found(name.clone(), function.span.clone()))?;
let input_value = self.allocate_main_function_input(
cs,
input_model.type_,
name.clone(),
input_option,
function.span.clone(),
)?;
.ok_or_else(|| FunctionError::input_not_found(name.clone(), function.span.clone()))?;
let input_value =
self.allocate_main_function_input(cs, input_model.type_, &name, input_option, &function.span)?;
(input_model.identifier, input_value)
}
};
// Store input as variable with {function_name}_{identifier_name}
let input_name = new_scope(function_name.clone(), identifier.name.clone());
let input_name = new_scope(&function_name, &identifier.name);
// Store a new variable for every allocated main function input
self.store(input_name, value);
@ -77,7 +72,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
}
let span = function.span.clone();
let result_value = self.enforce_function(cs, scope, function_name, function, input_variables, "".to_owned())?;
let result_value = self.enforce_function(cs, scope, &function_name, function, input_variables, "")?;
let output_bytes = OutputBytes::new_from_constrained_value(registers, result_value, span)?;
Ok(output_bytes)

8
compiler/src/function/result/result.rs
View File

@ -34,17 +34,17 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
cs: &mut CS,
return_value: &mut ConstrainedValue<F, G>,
results: Vec<(Option<Boolean>, ConstrainedValue<F, G>)>,
span: Span,
span: &Span,
) -> Result<(), StatementError> {
// if there are no results, continue
if results.len() == 0 {
if results.is_empty() {
return Ok(());
}
// If all indicators are none, then there are no branch conditions in the function.
// We simply return the last result.
if let None = results.iter().find(|(indicator, _res)| indicator.is_some()) {
if results.iter().all(|(indicator, _res)| indicator.is_none()) {
let result = &results[results.len() - 1].1;
*return_value = result.clone();
@ -65,7 +65,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let selected_value =
ConstrainedValue::conditionally_select(cs.ns(|| name_unique), &condition, &result, return_value)
.map_err(|_| {
StatementError::select_fail(result.to_string(), return_value.to_string(), span.clone())
StatementError::select_fail(result.to_string(), return_value.to_string(), span.to_owned())
})?;
*return_value = selected_value;

11
compiler/src/import/parser/import_parser.rs
View File

@ -21,7 +21,7 @@ use std::{collections::HashMap, env::current_dir};
/// Parses all relevant import files for a program.
/// Stores compiled program structs.
#[derive(Clone)]
#[derive(Clone, Default)]
pub struct ImportParser {
imports: HashMap<String, Program>,
core_packages: Vec<Package>,
@ -29,10 +29,7 @@ pub struct ImportParser {
impl ImportParser {
pub fn new() -> Self {
Self {
imports: HashMap::new(),
core_packages: vec![],
}
Self::default()
}
pub(crate) fn insert_import(&mut self, file_name: String, program: Program) {
@ -44,7 +41,7 @@ impl ImportParser {
let _res = self.core_packages.push(package.clone());
}
pub fn get_import(&self, file_name: &String) -> Option<&Program> {
pub fn get_import(&self, file_name: &str) -> Option<&Program> {
self.imports.get(file_name)
}
@ -56,7 +53,7 @@ impl ImportParser {
let mut imports = Self::new();
// Find all imports relative to current directory
let path = current_dir().map_err(|error| ImportError::current_directory_error(error))?;
let path = current_dir().map_err(ImportError::current_directory_error)?;
// Parse each imported file
program

11
compiler/src/import/parser/parse_package.rs
View File

@ -69,15 +69,13 @@ impl ImportParser {
}
let entries = fs::read_dir(path)
.map_err(|error| ImportError::directory_error(error, package_name.span.clone(), error_path.clone()))?
.into_iter()
.map_err(|error| ImportError::directory_error(error, package_name.span.clone(), &error_path))?
.collect::<Result<Vec<_>, std::io::Error>>()
.map_err(|error| ImportError::directory_error(error, package_name.span.clone(), error_path.clone()))?;
.map_err(|error| ImportError::directory_error(error, package_name.span.clone(), &error_path))?;
let matched_source_entry = entries.into_iter().find(|entry| {
entry
.file_name()
.to_os_string()
.into_string()
.unwrap()
.trim_end_matches(SOURCE_FILE_EXTENSION)
@ -89,10 +87,9 @@ impl ImportParser {
self.parse_core_package(&package)
} else if imports_directory.exists() {
let entries = fs::read_dir(imports_directory)
.map_err(|error| ImportError::directory_error(error, package_name.span.clone(), error_path.clone()))?
.into_iter()
.map_err(|error| ImportError::directory_error(error, package_name.span.clone(), &error_path))?
.collect::<Result<Vec<_>, std::io::Error>>()
.map_err(|error| ImportError::directory_error(error, package_name.span.clone(), error_path.clone()))?;
.map_err(|error| ImportError::directory_error(error, package_name.span.clone(), &error_path))?;
let matched_import_entry = entries
.into_iter()

9
compiler/src/import/parser/parse_symbol.rs
View File

@ -27,14 +27,13 @@ fn parse_import_file(entry: &DirEntry, span: &Span) -> Result<Program, ImportErr
// make sure the given entry is file
let file_type = entry
.file_type()
.map_err(|error| ImportError::directory_error(error, span.clone(), entry.path()))?;
.map_err(|error| ImportError::directory_error(error, span.clone(), &entry.path()))?;
let file_name = entry
.file_name()
.to_os_string()
.into_string()
.map_err(|_| ImportError::convert_os_string(span.clone()))?;
let mut file_path = entry.path().to_path_buf();
let mut file_path = entry.path();
if file_type.is_dir() {
file_path.push(LIBRARY_FILE);
@ -62,7 +61,7 @@ impl ImportParser {
.extension()
.map_or(false, |ext| ext.eq(&OsString::from(FILE_EXTENSION)));
let mut package_path = path.to_path_buf();
let mut package_path = path;
package_path.push(LIBRARY_FILE);
let is_package = is_dir && package_path.exists();
@ -93,7 +92,7 @@ impl ImportParser {
Ok(())
} else {
// importing * from a directory or non-leo file in `package/src/` is illegal
Err(ImportError::star(entry.path().to_path_buf(), span.clone()))
Err(ImportError::star(&entry.path(), span.clone()))
}
}

6
compiler/src/import/store/core_package.rs
View File

@ -21,7 +21,7 @@ use leo_core::{CorePackageList, LeoCoreError};
use snarkos_models::curves::{Field, PrimeField};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub(crate) fn store_core_package(&mut self, scope: String, package: Package) -> Result<(), LeoCoreError> {
pub(crate) fn store_core_package(&mut self, scope: &str, package: Package) -> Result<(), LeoCoreError> {
// Create list of imported core packages.
let list = CorePackageList::from_package_access(package.access)?;
@ -29,10 +29,10 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let symbol_list = list.to_symbols()?;
for (symbol, circuit) in symbol_list.symbols() {
let symbol_name = new_scope(scope.clone(), symbol);
let symbol_name = new_scope(scope, symbol);
// store packages
self.store(symbol_name, ConstrainedValue::CircuitDefinition(circuit))
self.store(symbol_name, ConstrainedValue::CircuitDefinition(circuit.to_owned()))
}
Ok(())

8
compiler/src/import/store/import.rs
View File

@ -22,7 +22,7 @@ use snarkos_models::curves::{Field, PrimeField};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub(crate) fn store_import(
&mut self,
scope: String,
scope: &str,
import: &Import,
imported_programs: &ImportParser,
) -> Result<(), ImportError> {
@ -33,7 +33,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
.find(|package| import.package.eq(package));
if let Some(package) = core_dependency {
self.store_core_package(scope.clone(), package.clone())?;
self.store_core_package(scope, package.clone())?;
return Ok(());
}
@ -45,13 +45,13 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Find imported program
let program = imported_programs
.get_import(&package)
.ok_or(ImportError::unknown_package(import.package.name.clone()))?;
.ok_or_else(|| ImportError::unknown_package(import.package.name.clone()))?;
// Parse imported program
self.store_definitions(program.clone(), imported_programs)?;
// Store the imported symbol
self.store_symbol(scope.clone(), package, &symbol, program)?;
self.store_symbol(scope, &package, &symbol, program)?;
}
Ok(())

22
compiler/src/import/store/symbol.rs
View File

@ -22,8 +22,8 @@ use snarkos_models::curves::{Field, PrimeField};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub(crate) fn store_symbol(
&mut self,
scope: String,
program_name: String,
scope: &str,
program_name: &str,
symbol: &ImportSymbol,
program: &Program,
) -> Result<(), ImportError> {
@ -31,9 +31,9 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
if symbol.is_star() {
// evaluate and store all circuit definitions
program.circuits.iter().for_each(|(identifier, circuit)| {
let name = new_scope(scope.clone(), identifier.to_string());
let name = new_scope(scope, &identifier.name);
let value = ConstrainedValue::Import(
program_name.clone(),
program_name.to_owned(),
Box::new(ConstrainedValue::CircuitDefinition(circuit.clone())),
);
@ -42,9 +42,9 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// evaluate and store all function definitions
program.functions.iter().for_each(|(identifier, function)| {
let name = new_scope(scope.clone(), identifier.to_string());
let name = new_scope(scope, &identifier.name);
let value = ConstrainedValue::Import(
program_name.clone(),
program_name.to_owned(),
Box::new(ConstrainedValue::Function(None, function.clone())),
);
@ -59,7 +59,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let value = match matched_circuit {
Some((_circuit_name, circuit)) => ConstrainedValue::Import(
program_name.clone(),
program_name.to_owned(),
Box::new(ConstrainedValue::CircuitDefinition(circuit.clone())),
),
None => {
@ -71,17 +71,17 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
match matched_function {
Some((_function_name, function)) => ConstrainedValue::Import(
program_name.clone(),
program_name.to_owned(),
Box::new(ConstrainedValue::Function(None, function.clone())),
),
None => return Err(ImportError::unknown_symbol(symbol.to_owned(), program_name)),
None => return Err(ImportError::unknown_symbol(symbol.to_owned(), program_name.to_owned())),
}
}
};
// take the alias if it is present
let id = symbol.alias.clone().unwrap_or(symbol.symbol.clone());
let name = new_scope(scope, id.to_string());
let id = symbol.alias.clone().unwrap_or_else(|| symbol.symbol.clone());
let name = new_scope(scope, &id.name);
// store imported circuit under imported name
self.store(name, value);

2
compiler/src/lib.rs
View File

@ -16,6 +16,8 @@
//! Module containing structs and types that make up a Leo program.
#![allow(clippy::module_inception)]
#[macro_use]
extern crate thiserror;

3
compiler/src/output/output_bytes.rs
View File

@ -71,8 +71,7 @@ impl OutputBytes {
string.push_str(&format);
}
let mut bytes: Vec<u8> = vec![];
bytes.extend_from_slice(string.as_bytes());
let bytes = string.into_bytes();
Ok(Self(bytes))
}

24
compiler/src/output/output_file.rs
View File

@ -19,9 +19,10 @@
use crate::errors::OutputFileError;
use std::{
borrow::Cow,
fs::{self, File},
io::Write,
path::PathBuf,
path::Path,
};
pub static OUTPUTS_DIRECTORY_NAME: &str = "outputs/";
@ -38,21 +39,21 @@ impl OutputFile {
}
}
pub fn exists_at(&self, path: &PathBuf) -> bool {
pub fn exists_at(&self, path: &Path) -> bool {
let path = self.setup_file_path(path);
path.exists()
}
/// Reads the output register variables from the given file path if it exists.
pub fn read_from(&self, path: &PathBuf) -> Result<String, OutputFileError> {
pub fn read_from(&self, path: &Path) -> Result<String, OutputFileError> {
let path = self.setup_file_path(path);
let output = fs::read_to_string(&path).map_err(|_| OutputFileError::FileReadError(path.clone()))?;
let output = fs::read_to_string(&path).map_err(|_| OutputFileError::FileReadError(path.into_owned()))?;
Ok(output)
}
/// Writes output to a file.
pub fn write(&self, path: &PathBuf, bytes: &[u8]) -> Result<(), OutputFileError> {
pub fn write(&self, path: &Path, bytes: &[u8]) -> Result<(), OutputFileError> {
// create output file
let path = self.setup_file_path(path);
let mut file = File::create(&path)?;
@ -62,23 +63,24 @@ impl OutputFile {
/// Removes the output file at the given path if it exists. Returns `true` on success,
/// `false` if the file doesn't exist, and `Error` if the file system fails during operation.
pub fn remove(&self, path: &PathBuf) -> Result<bool, OutputFileError> {
pub fn remove(&self, path: &Path) -> Result<bool, OutputFileError> {
let path = self.setup_file_path(path);
if !path.exists() {
return Ok(false);
}
fs::remove_file(&path).map_err(|_| OutputFileError::FileRemovalError(path.clone()))?;
fs::remove_file(&path).map_err(|_| OutputFileError::FileRemovalError(path.into_owned()))?;
Ok(true)
}
fn setup_file_path(&self, path: &PathBuf) -> PathBuf {
let mut path = path.to_owned();
fn setup_file_path<'a>(&self, path: &'a Path) -> Cow<'a, Path> {
let mut path = Cow::from(path);
if path.is_dir() {
if !path.ends_with(OUTPUTS_DIRECTORY_NAME) {
path.push(PathBuf::from(OUTPUTS_DIRECTORY_NAME));
path.to_mut().push(OUTPUTS_DIRECTORY_NAME);
}
path.push(PathBuf::from(format!("{}{}", self.package_name, OUTPUT_FILE_EXTENSION)));
path.to_mut()
.push(format!("{}{}", self.package_name, OUTPUT_FILE_EXTENSION));
}
path
}

21
compiler/src/program/program.rs
View File

@ -22,35 +22,40 @@ use snarkos_models::curves::{Field, PrimeField};
use std::collections::HashMap;
#[derive(Clone)]
pub struct ConstrainedProgram<F: Field + PrimeField, G: GroupType<F>> {
pub identifiers: HashMap<String, ConstrainedValue<F, G>>,
}
pub fn new_scope(outer: String, inner: String) -> String {
impl<F: Field + PrimeField, G: GroupType<F>> Default for ConstrainedProgram<F, G> {
fn default() -> Self {
Self {
identifiers: HashMap::new(),
}
}
}
pub fn new_scope(outer: &str, inner: &str) -> String {
format!("{}_{}", outer, inner)
}
pub fn is_in_scope(current_scope: &String, desired_scope: &String) -> bool {
pub fn is_in_scope(current_scope: &str, desired_scope: &str) -> bool {
current_scope.ends_with(desired_scope)
}
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn new() -> Self {
Self {
identifiers: HashMap::new(),
}
Self::default()
}
pub(crate) fn store(&mut self, name: String, value: ConstrainedValue<F, G>) {
self.identifiers.insert(name, value);
}
pub(crate) fn get(&self, name: &String) -> Option<&ConstrainedValue<F, G>> {
pub(crate) fn get(&self, name: &str) -> Option<&ConstrainedValue<F, G>> {
self.identifiers.get(name)
}
pub(crate) fn get_mut(&mut self, name: &String) -> Option<&mut ConstrainedValue<F, G>> {
pub(crate) fn get_mut(&mut self, name: &str) -> Option<&mut ConstrainedValue<F, G>> {
self.identifiers.get_mut(name)
}
}

39
compiler/src/statement/assign/array.rs
View File

@ -28,28 +28,29 @@ use snarkos_models::{
};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
#[allow(clippy::too_many_arguments)]
pub fn assign_array<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
file_scope: &str,
function_scope: &str,
indicator: Option<Boolean>,
name: String,
name: &str,
range_or_expression: RangeOrExpression,
mut new_value: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<(), StatementError> {
let condition = indicator.unwrap_or(Boolean::Constant(true));
// Resolve index so we know if we are assigning to a single value or a range of values
match range_or_expression {
RangeOrExpression::Expression(index) => {
let index = self.enforce_index(cs, file_scope.clone(), function_scope.clone(), index, span.clone())?;
let index = self.enforce_index(cs, file_scope, function_scope, index, span)?;
// Modify the single value of the array in place
match self.get_mutable_assignee(name, span.clone())? {
match self.get_mutable_assignee(name, &span)? {
ConstrainedValue::Array(old) => {
new_value.resolve_type(Some(old[index].to_type(span.clone())?), span.clone())?;
new_value.resolve_type(Some(old[index].to_type(&span)?), &span)?;
let name_unique = format!("select {} {}:{}", new_value, span.line, span.start);
let selected_value = ConstrainedValue::conditionally_select(
@ -59,34 +60,26 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
&old[index],
)
.map_err(|_| {
StatementError::select_fail(new_value.to_string(), old[index].to_string(), span)
StatementError::select_fail(new_value.to_string(), old[index].to_string(), span.to_owned())
})?;
old[index] = selected_value;
}
_ => return Err(StatementError::array_assign_index(span)),
_ => return Err(StatementError::array_assign_index(span.to_owned())),
}
}
RangeOrExpression::Range(from, to) => {
let from_index = match from {
Some(integer) => {
self.enforce_index(cs, file_scope.clone(), function_scope.clone(), integer, span.clone())?
}
Some(integer) => self.enforce_index(cs, file_scope, function_scope, integer, span)?,
None => 0usize,
};
let to_index_option = match to {
Some(integer) => Some(self.enforce_index(
cs,
file_scope.clone(),
function_scope.clone(),
integer,
span.clone(),
)?),
Some(integer) => Some(self.enforce_index(cs, file_scope, function_scope, integer, span)?),
None => None,
};
// Modify the range of values of the array
let old_array = self.get_mutable_assignee(name, span.clone())?;
let old_array = self.get_mutable_assignee(name, &span)?;
let new_array = match (old_array.clone(), new_value) {
(ConstrainedValue::Array(mut mutable), ConstrainedValue::Array(new)) => {
let to_index = to_index_option.unwrap_or(mutable.len());
@ -94,12 +87,14 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
mutable.splice(from_index..to_index, new.iter().cloned());
ConstrainedValue::Array(mutable)
}
_ => return Err(StatementError::array_assign_range(span)),
_ => return Err(StatementError::array_assign_range(span.to_owned())),
};
let name_unique = format!("select {} {}:{}", new_array, span.line, span.start);
let selected_array =
ConstrainedValue::conditionally_select(cs.ns(|| name_unique), &condition, &new_array, old_array)
.map_err(|_| StatementError::select_fail(new_array.to_string(), old_array.to_string(), span))?;
.map_err(|_| {
StatementError::select_fail(new_array.to_string(), old_array.to_string(), span.to_owned())
})?;
*old_array = selected_array;
}

36
compiler/src/statement/assign/assign.rs
View File

@ -35,58 +35,60 @@ use snarkos_models::{
};
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
#[allow(clippy::too_many_arguments)]
pub fn enforce_assign_statement<CS: ConstraintSystem<F>>(
&mut self,
cs: &mut CS,
file_scope: String,
function_scope: String,
declared_circuit_reference: String,
file_scope: &str,
function_scope: &str,
declared_circuit_reference: &str,
indicator: Option<Boolean>,
assignee: Assignee,
expression: Expression,
span: Span,
span: &Span,
) -> Result<(), StatementError> {
// Get the name of the variable we are assigning to
let variable_name = resolve_assignee(function_scope.clone(), assignee.clone());
let variable_name = resolve_assignee(function_scope, assignee.clone());
// Evaluate new value
let mut new_value =
self.enforce_expression(cs, file_scope.clone(), function_scope.clone(), None, expression)?;
let mut new_value = self.enforce_expression(cs, file_scope, function_scope, None, expression)?;
// Mutate the old value into the new value
match assignee {
Assignee::Identifier(_identifier) => {
let condition = indicator.unwrap_or(Boolean::Constant(true));
let old_value = self.get_mutable_assignee(variable_name.clone(), span.clone())?;
let old_value = self.get_mutable_assignee(&variable_name, &span)?;
new_value.resolve_type(Some(old_value.to_type(span.clone())?), span.clone())?;
new_value.resolve_type(Some(old_value.to_type(&span)?), &span)?;
let name_unique = format!("select {} {}:{}", new_value, span.line, span.start);
let selected_value =
ConstrainedValue::conditionally_select(cs.ns(|| name_unique), &condition, &new_value, old_value)
.map_err(|_| StatementError::select_fail(new_value.to_string(), old_value.to_string(), span))?;
.map_err(|_| {
StatementError::select_fail(new_value.to_string(), old_value.to_string(), span.to_owned())
})?;
*old_value = selected_value;
Ok(())
}
Assignee::Array(_assignee, range_or_expression) => self.assign_array(
Assignee::Array(assignee_w_range_or_expression) => self.assign_array(
cs,
file_scope,
function_scope,
indicator,
variable_name,
range_or_expression,
&variable_name,
assignee_w_range_or_expression.1,
new_value,
span,
),
Assignee::Tuple(_tuple, index) => self.assign_tuple(cs, indicator, variable_name, index, new_value, span),
Assignee::Tuple(_tuple, index) => self.assign_tuple(cs, indicator, &variable_name, index, new_value, span),
Assignee::CircuitField(assignee, circuit_variable) => {
// Mutate a circuit variable using the self keyword.
if let Assignee::Identifier(circuit_name) = *assignee {
if circuit_name.is_self() {
let self_circuit_variable_name = new_scope(circuit_name.name, circuit_variable.name.clone());
let self_variable_name = new_scope(file_scope, self_circuit_variable_name);
let self_circuit_variable_name = new_scope(&circuit_name.name, &circuit_variable.name);
let self_variable_name = new_scope(file_scope, &self_circuit_variable_name);
let value = self.mutate_circuit_variable(
cs,
indicator,
@ -101,7 +103,7 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
let _value = self.mutate_circuit_variable(
cs,
indicator,
variable_name,
&variable_name,
circuit_variable,
new_value,
span,

16
compiler/src/statement/assign/assignee.rs
View File

@ -21,10 +21,10 @@ use leo_typed::{Assignee, Span};
use snarkos_models::curves::{Field, PrimeField};
pub fn resolve_assignee(scope: String, assignee: Assignee) -> String {
pub fn resolve_assignee(scope: &str, assignee: Assignee) -> String {
match assignee {
Assignee::Identifier(name) => new_scope(scope, name.to_string()),
Assignee::Array(array, _index) => resolve_assignee(scope, *array),
Assignee::Identifier(name) => new_scope(scope, &name.to_string()),
Assignee::Array(array_w_index) => resolve_assignee(scope, array_w_index.0),
Assignee::Tuple(tuple, _index) => resolve_assignee(scope, *tuple),
Assignee::CircuitField(circuit_name, _member) => resolve_assignee(scope, *circuit_name),
}
@ -33,16 +33,16 @@ pub fn resolve_assignee(scope: String, assignee: Assignee) -> String {
impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
pub fn get_mutable_assignee(
&mut self,
name: String,
span: Span,
name: &str,
span: &Span,
) -> Result<&mut ConstrainedValue<F, G>, StatementError> {
// Check that assignee exists and is mutable
Ok(match self.get_mut(&name) {
Ok(match self.get_mut(name) {
Some(value) => match value {
ConstrainedValue::Mutable(mutable_value) => mutable_value,
_ => return Err(StatementError::immutable_assign(name, span)),
_ => return Err(StatementError::immutable_assign(name.to_owned(), span.to_owned())),
},
None => return Err(StatementError::undefined_variable(name, span)),
None => return Err(StatementError::undefined_variable(name.to_owned(), span.to_owned())),
})
}
}

37
compiler/src/statement/assign/circuit_variable.rs
View File

@ -32,18 +32,18 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
&mut self,
cs: &mut CS,
indicator: Option<Boolean>,
circuit_name: String,
circuit_name: &str,
variable_name: Identifier,
mut new_value: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<ConstrainedValue<F, G>, StatementError> {
let condition = indicator.unwrap_or(Boolean::Constant(true));
// Get the mutable circuit by name
match self.get_mutable_assignee(circuit_name, span.clone())? {
match self.get_mutable_assignee(circuit_name, span)? {
ConstrainedValue::CircuitExpression(_variable, members) => {
// Modify the circuit variable in place
let matched_variable = members.into_iter().find(|member| member.0 == variable_name);
let matched_variable = members.iter_mut().find(|member| member.0 == variable_name);
match matched_variable {
Some(member) => match &member.1 {
@ -51,18 +51,21 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
// Throw an error if we try to mutate a circuit function
Err(StatementError::immutable_circuit_function(
function.identifier.to_string(),
span,
span.to_owned(),
))
}
ConstrainedValue::Static(_circuit_function) => {
// Throw an error if we try to mutate a static circuit function
Err(StatementError::immutable_circuit_function("static".into(), span))
Err(StatementError::immutable_circuit_function(
"static".into(),
span.to_owned(),
))
}
ConstrainedValue::Mutable(value) => {
// Mutate the circuit variable's value in place
// Check that the new value type == old value type
new_value.resolve_type(Some(value.to_type(span.clone())?), span.clone())?;
new_value.resolve_type(Some(value.to_type(span)?), span)?;
// Conditionally select the value if this branch is executed.
let name_unique = format!("select {} {}:{}", new_value, span.line, span.start);
@ -73,7 +76,11 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
&member.1,
)
.map_err(|_| {
StatementError::select_fail(new_value.to_string(), member.1.to_string(), span)
StatementError::select_fail(
new_value.to_string(),
member.1.to_string(),
span.to_owned(),
)
})?;
// Make sure the new value is still mutable
@ -81,24 +88,30 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
member.1 = selected_value.to_owned();
Ok(selected_value.to_owned())
Ok(selected_value)
}
_ => {
// Throw an error if we try to mutate an immutable circuit variable
Err(StatementError::immutable_circuit_variable(variable_name.name, span))
Err(StatementError::immutable_circuit_variable(
variable_name.name,
span.to_owned(),
))
}
},
None => {
// Throw an error if the circuit variable does not exist in the circuit
Err(StatementError::undefined_circuit_variable(
variable_name.to_string(),
span,
span.to_owned(),
))
}
}
}
// Throw an error if the circuit definition does not exist in the file
_ => Err(StatementError::undefined_circuit(variable_name.to_string(), span)),
_ => Err(StatementError::undefined_circuit(
variable_name.to_string(),
span.to_owned(),
)),
}
}
}

12
compiler/src/statement/assign/tuple.rs
View File

@ -32,28 +32,28 @@ impl<F: Field + PrimeField, G: GroupType<F>> ConstrainedProgram<F, G> {
&mut self,
cs: &mut CS,
indicator: Option<Boolean>,
name: String,
name: &str,
index: usize,
mut new_value: ConstrainedValue<F, G>,
span: Span,
span: &Span,
) -> Result<(), StatementError> {
let condition = indicator.unwrap_or(Boolean::Constant(true));
// Modify the single value of the tuple in place
match self.get_mutable_assignee(name, span.clone())? {
match self.get_mutable_assignee(name, &span)? {
ConstrainedValue::Tuple(old) => {
new_value.resolve_type(Some(old[index].to_type(span.clone())?), span.clone())?;
new_value.resolve_type(Some(old[index].to_type(&span)?), &span)?;
let name_unique = format!("select {} {}:{}", new_value, span.line, span.start);
let selected_value =
ConstrainedValue::conditionally_select(cs.ns(|| name_unique), &condition, &new_value, &old[index])
.map_err(|_| {
StatementError::select_fail(new_value.to_string(), old[index].to_string(), span)
StatementError::select_fail(new_value.to_string(), old[index].to_string(), span.to_owned())
})?;
old[index] = selected_value;
}
_ => return Err(StatementError::tuple_assign_index(span)),
_ => return Err(StatementError::tuple_assign_index(span.to_owned())),
}
Ok(())

Some files were not shown because too many files have changed in this diff Show More