AleoHQ/leo
1
1
Fork 0
mirror of https://github.com/AleoHQ/leo.git synced 2024-12-29 20:44:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into feature/input-kebab

Browse Source
This commit is contained in:
damirka 2021-04-26 22:25:10 +03:00
commit 5d359f23f5
608 changed files with 7271 additions and 8043 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
.circleci/config.yml
View File

@ -158,6 +158,19 @@ jobs:
export LEO=/home/circleci/project/project/bin/leo
./project/.circleci/leo-add-remove.sh
leo-check-constraints:
docker:
- image: cimg/rust:1.50.0
resource_class: xlarge
steps:
- attach_workspace:
at: /home/circleci/project/
- run:
name: leo check constraints for Pedersen Hash
command: |
export LEO=/home/circleci/project/project/bin/leo
./project/.circleci/leo-check-constraints.sh
leo-login-logout:
docker:
- image: cimg/rust:1.51.0
@ -171,18 +184,18 @@ jobs:
export LEO=/home/circleci/project/project/bin/leo
./project/.circleci/leo-login-logout.sh
# leo-clone:
# docker:
# - image: cimg/rust:1.51.0
# resource_class: xlarge
# steps:
# - attach_workspace:
# at: /home/circleci/project/
# - run:
# name: leo clone
# command: |
# export LEO=/home/circleci/project/project/bin/leo
# ./project/.circleci/leo-clone.sh
leo-clone:
docker:
- image: cimg/rust:1.51.0
resource_class: xlarge
steps:
- attach_workspace:
at: /home/circleci/project/
- run:
name: leo clone
command: |
export LEO=/home/circleci/project/project/bin/leo
./project/.circleci/leo-clone.sh
leo-publish:
docker:
@ -219,12 +232,15 @@ workflows:
- leo-add-remove:
requires:
- leo-executable
- leo-check-constraints:
requires:
- leo-executable
- leo-login-logout:
requires:
- leo-executable
# - leo-clone:
# requires:
# - leo-executable
- leo-clone:
requires:
- leo-executable
- leo-publish:
requires:
- leo-executable

16
.circleci/leo-check-constraints.sh Executable file
View File

@ -0,0 +1,16 @@
# leo new hello-world
cd ./project/examples/pedersen-hash
export PEDERSEN_HASH_CONSTRAINTS=1539;
# line that we're searching for is:
# `Build Number of constraints - 1539`
export ACTUAL_CONSTRAINTS=$($LEO build | grep constraints | awk '{print $NF}')
# if else expression with only else block
[[ PEDERSEN_HASH_CONSTRAINTS -eq ACTUAL_CONSTRAINTS ]] || {
echo >&2 "Number of constraints for Pedersen Hash is not $PEDERSEN_HASH_CONSTRAINTS";
echo >&2 "Real number of constraints is $ACTUAL_CONSTRAINTS";
exit 1;
}

176
Cargo.lock generated
View File

@ -87,6 +87,20 @@ version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
[[package]]
name = "assert_cmd"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2475b58cd94eb4f70159f4fd8844ba3b807532fe3131b3373fae060bbe30396"
dependencies = [
"bstr",
"doc-comment",
"predicates",
"predicates-core",
"predicates-tree",
"wait-timeout",
]
[[package]]
name = "atty"
version = "0.2.14"
@ -601,6 +615,12 @@ dependencies = [
"syn 1.0.64",
]
[[package]]
name = "difference"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"
[[package]]
name = "digest"
version = "0.8.1"
@ -639,6 +659,12 @@ dependencies = [
"winapi 0.3.9",
]
[[package]]
name = "doc-comment"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
[[package]]
name = "dtoa"
version = "0.4.8"
@ -1307,8 +1333,8 @@ dependencies = [
"leo-state",
"num-bigint",
"pest",
"rand",
"rand_core",
"rand 0.8.3",
"rand_core 0.6.2",
"rand_xorshift",
"serde",
"sha2",
@ -1320,6 +1346,7 @@ dependencies = [
"snarkvm-r1cs",
"snarkvm-utilities",
"tempfile",
"tendril",
"thiserror",
"tracing",
]
@ -1354,6 +1381,7 @@ version = "1.4.0"
dependencies = [
"ansi_term 0.12.1",
"anyhow",
"assert_cmd",
"clap",
"colored",
"console",
@ -1368,8 +1396,8 @@ dependencies = [
"leo-state",
"leo-synthesizer",
"notify",
"rand",
"rand_core",
"rand 0.8.3",
"rand_core 0.6.2",
"reqwest",
"rusty-hook",
"self_update",
@ -1381,6 +1409,7 @@ dependencies = [
"snarkvm-r1cs",
"snarkvm-utilities",
"structopt",
"test_dir",
"thiserror",
"toml",
"tracing",
@ -1413,6 +1442,7 @@ dependencies = [
"indexmap",
"lazy_static",
"leo-ast",
"leo-test-framework",
"serde",
"serde_json",
"serde_yaml",
@ -1428,8 +1458,8 @@ dependencies = [
"indexmap",
"leo-ast",
"leo-input",
"rand",
"rand_core",
"rand 0.8.3",
"rand_core 0.6.2",
"rand_xorshift",
"snarkvm-algorithms",
"snarkvm-curves",
@ -1452,6 +1482,15 @@ dependencies = [
"snarkvm-r1cs",
]
[[package]]
name = "leo-test-framework"
version = "1.4.0"
dependencies = [
"serde",
"serde_json",
"serde_yaml",
]
[[package]]
name = "lexical-core"
version = "0.7.5"
@ -2037,6 +2076,32 @@ version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
[[package]]
name = "predicates"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eeb433456c1a57cc93554dea3ce40b4c19c4057e41c55d4a0f3d84ea71c325aa"
dependencies = [
"difference",
"predicates-core",
]
[[package]]
name = "predicates-core"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57e35a3326b75e49aa85f5dc6ec15b41108cf5aee58eabb1f274dd18b73c2451"
[[package]]
name = "predicates-tree"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "15f553275e5721409451eb85e15fd9a860a6e5ab4496eb215987502b5f5391f2"
dependencies = [
"predicates-core",
"treeline",
]
[[package]]
name = "proc-macro-crate"
version = "0.1.5"
@ -2127,6 +2192,19 @@ version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "941ba9d78d8e2f7ce474c015eea4d9c6d25b6a3327f9832ee29a4de27f91bbb8"
[[package]]
name = "rand"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
dependencies = [
"getrandom 0.1.16",
"libc",
"rand_chacha 0.2.2",
"rand_core 0.5.1",
"rand_hc 0.2.0",
]
[[package]]
name = "rand"
version = "0.8.3"
@ -2134,9 +2212,19 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ef9e7e66b4468674bfcb0c81af8b7fa0bb154fa9f28eb840da5c447baeb8d7e"
dependencies = [
"libc",
"rand_chacha",
"rand_core",
"rand_hc",
"rand_chacha 0.3.0",
"rand_core 0.6.2",
"rand_hc 0.3.0",
]
[[package]]
name = "rand_chacha"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
"ppv-lite86",
"rand_core 0.5.1",
]
[[package]]
@ -2146,7 +2234,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e12735cf05c9e10bf21534da50a147b924d555dc7a547c42e6bb2d5b6017ae0d"
dependencies = [
"ppv-lite86",
"rand_core",
"rand_core 0.6.2",
]
[[package]]
name = "rand_core"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
dependencies = [
"getrandom 0.1.16",
]
[[package]]
@ -2158,13 +2255,22 @@ dependencies = [
"getrandom 0.2.2",
]
[[package]]
name = "rand_hc"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
dependencies = [
"rand_core 0.5.1",
]
[[package]]
name = "rand_hc"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3190ef7066a446f2e7f42e239d161e905420ccab01eb967c9eb27d21b2322a73"
dependencies = [
"rand_core",
"rand_core 0.6.2",
]
[[package]]
@ -2173,7 +2279,7 @@ version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
dependencies = [
"rand_core",
"rand_core 0.6.2",
]
[[package]]
@ -2604,8 +2710,8 @@ dependencies = [
"derivative",
"digest 0.9.0",
"itertools 0.10.0",
"rand",
"rand_chacha",
"rand 0.8.3",
"rand_chacha 0.3.0",
"rayon",
"sha2",
"smallvec",
@ -2624,7 +2730,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "64610b135b8b1152439d5dfa4f745515933366082f08651961344aa0bb5abfca"
dependencies = [
"derivative",
"rand",
"rand 0.8.3",
"rand_xorshift",
"rustc_version 0.3.3",
"serde",
@ -2659,7 +2765,7 @@ dependencies = [
"derivative",
"hex",
"itertools 0.10.0",
"rand",
"rand 0.8.3",
"snarkvm-algorithms",
"snarkvm-curves",
"snarkvm-fields",
@ -2680,7 +2786,7 @@ checksum = "8c49c69d02df11be58e07f626c9d6f5804c6dd4ccf42e425f2be8d79fe6e5bb7"
dependencies = [
"bincode",
"derivative",
"rand",
"rand 0.8.3",
"rand_xorshift",
"serde",
"snarkvm-utilities",
@ -2715,7 +2821,7 @@ dependencies = [
"chrono",
"hex",
"once_cell",
"rand",
"rand 0.8.3",
"serde",
"sha2",
"snarkvm-algorithms",
@ -2769,7 +2875,7 @@ dependencies = [
"bincode",
"hex",
"parking_lot",
"rand",
"rand 0.8.3",
"rocksdb",
"serde",
"snarkvm-algorithms",
@ -2787,7 +2893,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c763843fa67a3aa4ce68173c8cd96b4f04aaa135a5792bc051c36eec0fe1cd73"
dependencies = [
"bincode",
"rand",
"rand 0.8.3",
"snarkvm-derives",
"thiserror",
]
@ -2893,7 +2999,7 @@ checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
dependencies = [
"cfg-if 1.0.0",
"libc",
"rand",
"rand 0.8.3",
"redox_syscall 0.2.5",
"remove_dir_all",
"winapi 0.3.9",
@ -2929,6 +3035,15 @@ dependencies = [
"winapi 0.3.9",
]
[[package]]
name = "test_dir"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e571ebf9127a9da821890a9fa8a8ef777fce3e0f959ff6949cf06ca8b736381d"
dependencies = [
"rand 0.7.3",
]
[[package]]
name = "textwrap"
version = "0.11.0"
@ -3141,6 +3256,12 @@ dependencies = [
"tracing-serde",
]
[[package]]
name = "treeline"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7f741b240f1a48843f9b8e0444fb55fb2a4ff67293b50a9179dfd5ea67f8d41"
[[package]]
name = "try-lock"
version = "0.2.3"
@ -3258,6 +3379,15 @@ version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
[[package]]
name = "wait-timeout"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
dependencies = [
"libc",
]
[[package]]
name = "walkdir"
version = "2.3.2"
@ -3457,9 +3587,9 @@ dependencies = [
[[package]]
name = "zip"
version = "0.5.10"
version = "0.5.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a8977234acab718eb2820494b2f96cbb16004c19dddf88b7445b27381450997"
checksum = "9c83dc9b784d252127720168abd71ea82bf8c3d96b17dc565b5e2a02854f2b27"
dependencies = [
"byteorder",
"bzip2",

9
Cargo.toml
View File

@ -37,7 +37,8 @@ members = [
"package",
"parser",
"state",
"synthesizer"
"synthesizer",
"test-framework"
]
[dependencies.leo-ast]
@ -156,6 +157,12 @@ version = "0.12.1"
[dev-dependencies.rusty-hook]
version = "0.11.2"
[dev-dependencies.assert_cmd]
version = "1.0.3"
[dev-dependencies.test_dir]
version = "0.1.0"
[features]
default = [ ]
ci_skip = [ "leo-compiler/ci_skip" ]

4
ast/src/reducer/errors.rs → ast/src/errors/canonicalization.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::{FormattedError, Span};
use crate::{FormattedError, LeoError, Span};
#[derive(Debug, Error)]
pub enum CanonicalizeError {
@ -22,6 +22,8 @@ pub enum CanonicalizeError {
Error(#[from] FormattedError),
}
impl LeoError for CanonicalizeError {}
impl CanonicalizeError {
fn new_from_span(message: String, span: &Span) -> Self {
CanonicalizeError::Error(FormattedError::new_from_span(message, span))

43
ast/src/errors/combiner.rs Normal file
View File

@ -0,0 +1,43 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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::{FormattedError, LeoError, Span};
#[derive(Debug, Error)]
pub enum CombinerError {
#[error("{}", _0)]
Error(#[from] FormattedError),
}
impl LeoError for CombinerError {}
impl CombinerError {
fn new_from_span(message: String, span: &Span) -> Self {
CombinerError::Error(FormattedError::new_from_span(message, span))
}
pub fn asg_statement_not_block(span: &Span) -> Self {
let message = "AstStatement should be be a block".to_string();
Self::new_from_span(message, span)
}
pub fn illegal_compound_array_range(span: &Span) -> Self {
let message = "Illegal compound assignement with array range".to_string();
Self::new_from_span(message, span)
}
}

9
ast/src/errors/mod.rs
View File

@ -14,7 +14,16 @@
// 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/>.
pub mod canonicalization;
pub use canonicalization::*;
pub mod combiner;
pub use combiner::*;
pub mod error;
pub use error::*;
pub mod reducer;
pub use reducer::*;
pub trait LeoError {}

43
ast/src/errors/reducer.rs Normal file
View File

@ -0,0 +1,43 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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::{CanonicalizeError, CombinerError, FormattedError, LeoError, Span};
#[derive(Debug, Error)]
pub enum ReducerError {
#[error("{}", _0)]
Error(#[from] FormattedError),
#[error("{}", _0)]
CanonicalizeError(#[from] CanonicalizeError),
#[error("{}", _0)]
CombinerError(#[from] CombinerError),
}
impl LeoError for ReducerError {}
impl ReducerError {
fn new_from_span(message: String, span: &Span) -> Self {
ReducerError::Error(FormattedError::new_from_span(message, span))
}
pub fn impossible_console_assert_call(span: &Span) -> Self {
let message = "Console::Assert cannot be matched here, its handled in another case.".to_string();
Self::new_from_span(message, span)
}
}

4
ast/src/lib.rs
View File

@ -71,7 +71,7 @@ pub use node::*;
/// These data types form a tree that begins from a [`Program`] type root.
///
/// A new [`Ast`] can be created from a [`Grammar`] generated by the pest parser in the `grammar` module.
#[derive(Debug, Eq, PartialEq)]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Ast {
ast: Program,
}
@ -83,7 +83,7 @@ impl Ast {
}
/// Mutates the program ast by preforming canonicalization on it.
pub fn canonicalize(&mut self) -> Result<(), CanonicalizeError> {
pub fn canonicalize(&mut self) -> Result<(), ReducerError> {
self.ast = ReconstructingDirector::new(Canonicalizer::default()).reduce_program(self.as_repr())?;
Ok(())
}

186
ast/src/reducer/canonicalization.rs
View File

@ -25,11 +25,78 @@ use crate::*;
pub struct Canonicalizer {
// If we are in a circuit keep track of the circuit name.
circuit_name: Option<Identifier>,
in_circuit: bool,
}
impl Default for Canonicalizer {
fn default() -> Self {
Self {
circuit_name: None,
in_circuit: false,
}
}
}
impl Canonicalizer {
pub fn default() -> Self {
Self { circuit_name: None }
pub fn canonicalize_accesses(
&mut self,
start: Expression,
accesses: &[AssigneeAccess],
span: &Span,
) -> Result<Box<Expression>, ReducerError> {
let mut left = Box::new(start);
for access in accesses.iter() {
match self.canonicalize_assignee_access(&access) {
AssigneeAccess::ArrayIndex(index) => {
left = Box::new(Expression::ArrayAccess(ArrayAccessExpression {
array: left,
index: Box::new(index),
span: span.clone(),
}));
}
AssigneeAccess::Tuple(positive_number, _) => {
left = Box::new(Expression::TupleAccess(TupleAccessExpression {
tuple: left,
index: positive_number,
span: span.clone(),
}));
}
AssigneeAccess::Member(identifier) => {
left = Box::new(Expression::CircuitMemberAccess(CircuitMemberAccessExpression {
circuit: left,
name: identifier,
span: span.clone(),
}));
}
_ => return Err(ReducerError::from(CombinerError::illegal_compound_array_range(&span))),
}
}
Ok(left)
}
pub fn compound_operation_converstion(
&mut self,
operation: &AssignOperation,
) -> Result<BinaryOperation, ReducerError> {
match operation {
AssignOperation::Assign => unreachable!(),
AssignOperation::Add => Ok(BinaryOperation::Add),
AssignOperation::Sub => Ok(BinaryOperation::Sub),
AssignOperation::Mul => Ok(BinaryOperation::Mul),
AssignOperation::Div => Ok(BinaryOperation::Div),
AssignOperation::Pow => Ok(BinaryOperation::Pow),
AssignOperation::Or => Ok(BinaryOperation::Or),
AssignOperation::And => Ok(BinaryOperation::And),
AssignOperation::BitOr => Ok(BinaryOperation::BitOr),
AssignOperation::BitAnd => Ok(BinaryOperation::BitAnd),
AssignOperation::BitXor => Ok(BinaryOperation::BitXor),
AssignOperation::Shr => Ok(BinaryOperation::Shr),
AssignOperation::ShrSigned => Ok(BinaryOperation::ShrSigned),
AssignOperation::Shl => Ok(BinaryOperation::Shl),
AssignOperation::Mod => Ok(BinaryOperation::Mod),
}
}
fn is_self_type(&mut self, type_option: Option<&Type>) -> bool {
@ -380,17 +447,21 @@ impl Canonicalizer {
}
impl ReconstructingReducer for Canonicalizer {
fn reduce_type(
&mut self,
_type_: &Type,
new: Type,
in_circuit: bool,
span: &Span,
) -> Result<Type, CanonicalizeError> {
fn in_circuit(&self) -> bool {
self.in_circuit
}
fn swap_in_circuit(&mut self) {
self.in_circuit = !self.in_circuit;
}
fn reduce_type(&mut self, _type_: &Type, new: Type, span: &Span) -> Result<Type, ReducerError> {
match new {
Type::Array(type_, mut dimensions) => {
if dimensions.is_zero() {
return Err(CanonicalizeError::invalid_array_dimension_size(span));
return Err(ReducerError::from(CanonicalizeError::invalid_array_dimension_size(
span,
)));
}
let mut next = Type::Array(type_, ArrayDimensions(vec![dimensions.remove_last().unwrap()]));
@ -407,7 +478,9 @@ impl ReconstructingReducer for Canonicalizer {
Ok(array)
}
Type::SelfType if !in_circuit => Err(CanonicalizeError::big_self_outside_of_circuit(span)),
Type::SelfType if !self.in_circuit => {
Err(ReducerError::from(CanonicalizeError::big_self_outside_of_circuit(span)))
}
_ => Ok(new.clone()),
}
}
@ -416,10 +489,11 @@ impl ReconstructingReducer for Canonicalizer {
&mut self,
array_init: &ArrayInitExpression,
element: Expression,
_in_circuit: bool,
) -> Result<ArrayInitExpression, CanonicalizeError> {
) -> Result<ArrayInitExpression, ReducerError> {
if array_init.dimensions.is_zero() {
return Err(CanonicalizeError::invalid_array_dimension_size(&array_init.span));
return Err(ReducerError::from(CanonicalizeError::invalid_array_dimension_size(
&array_init.span,
)));
}
let element = Box::new(element);
@ -466,58 +540,39 @@ impl ReconstructingReducer for Canonicalizer {
assign: &AssignStatement,
assignee: Assignee,
value: Expression,
_in_circuit: bool,
) -> Result<AssignStatement, CanonicalizeError> {
) -> Result<AssignStatement, ReducerError> {
match value {
Expression::Binary(binary_expr) if assign.operation != AssignOperation::Assign => {
let left = self.canonicalize_accesses(
Expression::Identifier(assignee.identifier.clone()),
&assignee.accesses,
&assign.span,
)?;
let right = Box::new(Expression::Binary(binary_expr));
let op = self.compound_operation_converstion(&assign.operation)?;
let new_value = Expression::Binary(BinaryExpression {
left,
right,
op,
span: assign.span.clone(),
});
Ok(AssignStatement {
operation: AssignOperation::Assign,
assignee,
value: new_value,
span: assign.span.clone(),
})
}
Expression::Value(value_expr) if assign.operation != AssignOperation::Assign => {
let mut left = Box::new(Expression::Identifier(assignee.identifier.clone()));
for access in assignee.accesses.iter() {
match self.canonicalize_assignee_access(&access) {
AssigneeAccess::ArrayIndex(index) => {
left = Box::new(Expression::ArrayAccess(ArrayAccessExpression {
array: left,
index: Box::new(index),
span: assign.span.clone(),
}));
}
AssigneeAccess::Tuple(positive_number, _) => {
left = Box::new(Expression::TupleAccess(TupleAccessExpression {
tuple: left,
index: positive_number,
span: assign.span.clone(),
}));
}
AssigneeAccess::Member(identifier) => {
left = Box::new(Expression::CircuitMemberAccess(CircuitMemberAccessExpression {
circuit: left,
name: identifier,
span: assign.span.clone(),
}));
}
_ => unimplemented!(), // No reason for someone to compute ArrayRanges.
}
}
let left = self.canonicalize_accesses(
Expression::Identifier(assignee.identifier.clone()),
&assignee.accesses,
&assign.span,
)?;
let right = Box::new(Expression::Value(value_expr));
let op = match assign.operation {
AssignOperation::Assign => unimplemented!(), // Imposible
AssignOperation::Add => BinaryOperation::Add,
AssignOperation::Sub => BinaryOperation::Sub,
AssignOperation::Mul => BinaryOperation::Mul,
AssignOperation::Div => BinaryOperation::Div,
AssignOperation::Pow => BinaryOperation::Pow,
AssignOperation::Or => BinaryOperation::Or,
AssignOperation::And => BinaryOperation::And,
AssignOperation::BitOr => BinaryOperation::BitOr,
AssignOperation::BitAnd => BinaryOperation::BitAnd,
AssignOperation::BitXor => BinaryOperation::BitXor,
AssignOperation::Shr => BinaryOperation::Shr,
AssignOperation::ShrSigned => BinaryOperation::ShrSigned,
AssignOperation::Shl => BinaryOperation::Shl,
AssignOperation::Mod => BinaryOperation::Mod,
};
let op = self.compound_operation_converstion(&assign.operation)?;
let new_value = Expression::Binary(BinaryExpression {
left,
@ -545,8 +600,7 @@ impl ReconstructingReducer for Canonicalizer {
input: Vec<FunctionInput>,
output: Option<Type>,
block: Block,
_in_circuit: bool,
) -> Result<Function, CanonicalizeError> {
) -> Result<Function, ReducerError> {
let new_output = match output {
None => Some(Type::Tuple(vec![])),
_ => output,
@ -567,7 +621,7 @@ impl ReconstructingReducer for Canonicalizer {
_circuit: &Circuit,
circuit_name: Identifier,
members: Vec<CircuitMember>,
) -> Result<Circuit, CanonicalizeError> {
) -> Result<Circuit, ReducerError> {
self.circuit_name = Some(circuit_name.clone());
let circ = Circuit {
circuit_name,

3
ast/src/reducer/mod.rs
View File

@ -17,9 +17,6 @@
mod canonicalization;
pub use canonicalization::*;
mod errors;
pub use errors::*;
mod reconstructing_reducer;
pub use reconstructing_reducer::*;

196
ast/src/reducer/reconstructing_director.rs
View File

@ -22,18 +22,14 @@ use indexmap::IndexMap;
pub struct ReconstructingDirector<R: ReconstructingReducer> {
reducer: R,
in_circuit: bool,
}
impl<R: ReconstructingReducer> ReconstructingDirector<R> {
pub fn new(reducer: R) -> Self {
Self {
reducer,
in_circuit: false,
}
Self { reducer }
}
pub fn reduce_type(&mut self, type_: &Type, span: &Span) -> Result<Type, CanonicalizeError> {
pub fn reduce_type(&mut self, type_: &Type, span: &Span) -> Result<Type, ReducerError> {
let new = match type_ {
Type::Array(type_, dimensions) => Type::Array(Box::new(self.reduce_type(type_, span)?), dimensions.clone()),
Type::Tuple(types) => {
@ -48,11 +44,11 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
_ => type_.clone(),
};
self.reducer.reduce_type(type_, new, self.in_circuit, span)
self.reducer.reduce_type(type_, new, span)
}
// Expressions
pub fn reduce_expression(&mut self, expression: &Expression) -> Result<Expression, CanonicalizeError> {
pub fn reduce_expression(&mut self, expression: &Expression) -> Result<Expression, ReducerError> {
let new = match expression {
Expression::Identifier(identifier) => Expression::Identifier(self.reduce_identifier(&identifier)?),
Expression::Value(value) => Expression::Value(self.reduce_value(&value)?),
@ -84,18 +80,18 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
Expression::Call(call) => Expression::Call(self.reduce_call(&call)?),
};
self.reducer.reduce_expression(expression, new, self.in_circuit)
self.reducer.reduce_expression(expression, new)
}
pub fn reduce_identifier(&mut self, identifier: &Identifier) -> Result<Identifier, CanonicalizeError> {
pub fn reduce_identifier(&mut self, identifier: &Identifier) -> Result<Identifier, ReducerError> {
self.reducer.reduce_identifier(identifier)
}
pub fn reduce_group_tuple(&mut self, group_tuple: &GroupTuple) -> Result<GroupTuple, CanonicalizeError> {
pub fn reduce_group_tuple(&mut self, group_tuple: &GroupTuple) -> Result<GroupTuple, ReducerError> {
self.reducer.reduce_group_tuple(group_tuple)
}
pub fn reduce_group_value(&mut self, group_value: &GroupValue) -> Result<GroupValue, CanonicalizeError> {
pub fn reduce_group_value(&mut self, group_value: &GroupValue) -> Result<GroupValue, ReducerError> {
let new = match group_value {
GroupValue::Tuple(group_tuple) => GroupValue::Tuple(self.reduce_group_tuple(&group_tuple)?),
_ => group_value.clone(),
@ -104,7 +100,7 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
self.reducer.reduce_group_value(group_value, new)
}
pub fn reduce_value(&mut self, value: &ValueExpression) -> Result<ValueExpression, CanonicalizeError> {
pub fn reduce_value(&mut self, value: &ValueExpression) -> Result<ValueExpression, ReducerError> {
let new = match value {
ValueExpression::Group(group_value) => {
ValueExpression::Group(Box::new(self.reduce_group_value(&group_value)?))
@ -115,41 +111,38 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
self.reducer.reduce_value(value, new)
}
pub fn reduce_binary(&mut self, binary: &BinaryExpression) -> Result<BinaryExpression, CanonicalizeError> {
pub fn reduce_binary(&mut self, binary: &BinaryExpression) -> Result<BinaryExpression, ReducerError> {
let left = self.reduce_expression(&binary.left)?;
let right = self.reduce_expression(&binary.right)?;
self.reducer
.reduce_binary(binary, left, right, binary.op.clone(), self.in_circuit)
self.reducer.reduce_binary(binary, left, right, binary.op.clone())
}
pub fn reduce_unary(&mut self, unary: &UnaryExpression) -> Result<UnaryExpression, CanonicalizeError> {
pub fn reduce_unary(&mut self, unary: &UnaryExpression) -> Result<UnaryExpression, ReducerError> {
let inner = self.reduce_expression(&unary.inner)?;
self.reducer
.reduce_unary(unary, inner, unary.op.clone(), self.in_circuit)
self.reducer.reduce_unary(unary, inner, unary.op.clone())
}
pub fn reduce_ternary(&mut self, ternary: &TernaryExpression) -> Result<TernaryExpression, CanonicalizeError> {
pub fn reduce_ternary(&mut self, ternary: &TernaryExpression) -> Result<TernaryExpression, ReducerError> {
let condition = self.reduce_expression(&ternary.condition)?;
let if_true = self.reduce_expression(&ternary.if_true)?;
let if_false = self.reduce_expression(&ternary.if_false)?;
self.reducer
.reduce_ternary(ternary, condition, if_true, if_false, self.in_circuit)
self.reducer.reduce_ternary(ternary, condition, if_true, if_false)
}
pub fn reduce_cast(&mut self, cast: &CastExpression) -> Result<CastExpression, CanonicalizeError> {
pub fn reduce_cast(&mut self, cast: &CastExpression) -> Result<CastExpression, ReducerError> {
let inner = self.reduce_expression(&cast.inner)?;
let target_type = self.reduce_type(&cast.target_type, &cast.span)?;
self.reducer.reduce_cast(cast, inner, target_type, self.in_circuit)
self.reducer.reduce_cast(cast, inner, target_type)
}
pub fn reduce_array_inline(
&mut self,
array_inline: &ArrayInlineExpression,
) -> Result<ArrayInlineExpression, CanonicalizeError> {
) -> Result<ArrayInlineExpression, ReducerError> {
let mut elements = vec![];
for element in array_inline.elements.iter() {
let reduced_element = match element {
@ -164,34 +157,29 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
elements.push(reduced_element);
}
self.reducer
.reduce_array_inline(array_inline, elements, self.in_circuit)
self.reducer.reduce_array_inline(array_inline, elements)
}
pub fn reduce_array_init(
&mut self,
array_init: &ArrayInitExpression,
) -> Result<ArrayInitExpression, CanonicalizeError> {
pub fn reduce_array_init(&mut self, array_init: &ArrayInitExpression) -> Result<ArrayInitExpression, ReducerError> {
let element = self.reduce_expression(&array_init.element)?;
self.reducer.reduce_array_init(array_init, element, self.in_circuit)
self.reducer.reduce_array_init(array_init, element)
}
pub fn reduce_array_access(
&mut self,
array_access: &ArrayAccessExpression,
) -> Result<ArrayAccessExpression, CanonicalizeError> {
) -> Result<ArrayAccessExpression, ReducerError> {
let array = self.reduce_expression(&array_access.array)?;
let index = self.reduce_expression(&array_access.index)?;
self.reducer
.reduce_array_access(array_access, array, index, self.in_circuit)
self.reducer.reduce_array_access(array_access, array, index)
}
pub fn reduce_array_range_access(
&mut self,
array_range_access: &ArrayRangeAccessExpression,
) -> Result<ArrayRangeAccessExpression, CanonicalizeError> {
) -> Result<ArrayRangeAccessExpression, ReducerError> {
let array = self.reduce_expression(&array_range_access.array)?;
let left = array_range_access
.left
@ -205,34 +193,31 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
.transpose()?;
self.reducer
.reduce_array_range_access(array_range_access, array, left, right, self.in_circuit)
.reduce_array_range_access(array_range_access, array, left, right)
}
pub fn reduce_tuple_init(
&mut self,
tuple_init: &TupleInitExpression,
) -> Result<TupleInitExpression, CanonicalizeError> {
pub fn reduce_tuple_init(&mut self, tuple_init: &TupleInitExpression) -> Result<TupleInitExpression, ReducerError> {
let mut elements = vec![];
for element in tuple_init.elements.iter() {
elements.push(self.reduce_expression(element)?);
}
self.reducer.reduce_tuple_init(tuple_init, elements, self.in_circuit)
self.reducer.reduce_tuple_init(tuple_init, elements)
}
pub fn reduce_tuple_access(
&mut self,
tuple_access: &TupleAccessExpression,
) -> Result<TupleAccessExpression, CanonicalizeError> {
) -> Result<TupleAccessExpression, ReducerError> {
let tuple = self.reduce_expression(&tuple_access.tuple)?;
self.reducer.reduce_tuple_access(tuple_access, tuple, self.in_circuit)
self.reducer.reduce_tuple_access(tuple_access, tuple)
}
pub fn reduce_circuit_implied_variable_definition(
&mut self,
variable: &CircuitImpliedVariableDefinition,
) -> Result<CircuitImpliedVariableDefinition, CanonicalizeError> {
) -> Result<CircuitImpliedVariableDefinition, ReducerError> {
let identifier = self.reduce_identifier(&variable.identifier)?;
let expression = variable
.expression
@ -241,13 +226,13 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
.transpose()?;
self.reducer
.reduce_circuit_implied_variable_definition(variable, identifier, expression, self.in_circuit)
.reduce_circuit_implied_variable_definition(variable, identifier, expression)
}
pub fn reduce_circuit_init(
&mut self,
circuit_init: &CircuitInitExpression,
) -> Result<CircuitInitExpression, CanonicalizeError> {
) -> Result<CircuitInitExpression, ReducerError> {
let name = self.reduce_identifier(&circuit_init.name)?;
let mut members = vec![];
@ -255,33 +240,32 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
members.push(self.reduce_circuit_implied_variable_definition(member)?);
}
self.reducer
.reduce_circuit_init(circuit_init, name, members, self.in_circuit)
self.reducer.reduce_circuit_init(circuit_init, name, members)
}
pub fn reduce_circuit_member_access(
&mut self,
circuit_member_access: &CircuitMemberAccessExpression,
) -> Result<CircuitMemberAccessExpression, CanonicalizeError> {
) -> Result<CircuitMemberAccessExpression, ReducerError> {
let circuit = self.reduce_expression(&circuit_member_access.circuit)?;
let name = self.reduce_identifier(&circuit_member_access.name)?;
self.reducer
.reduce_circuit_member_access(circuit_member_access, circuit, name, self.in_circuit)
.reduce_circuit_member_access(circuit_member_access, circuit, name)
}
pub fn reduce_circuit_static_fn_access(
&mut self,
circuit_static_fn_access: &CircuitStaticFunctionAccessExpression,
) -> Result<CircuitStaticFunctionAccessExpression, CanonicalizeError> {
) -> Result<CircuitStaticFunctionAccessExpression, ReducerError> {
let circuit = self.reduce_expression(&circuit_static_fn_access.circuit)?;
let name = self.reduce_identifier(&circuit_static_fn_access.name)?;
self.reducer
.reduce_circuit_static_fn_access(circuit_static_fn_access, circuit, name, self.in_circuit)
.reduce_circuit_static_fn_access(circuit_static_fn_access, circuit, name)
}
pub fn reduce_call(&mut self, call: &CallExpression) -> Result<CallExpression, CanonicalizeError> {
pub fn reduce_call(&mut self, call: &CallExpression) -> Result<CallExpression, ReducerError> {
let function = self.reduce_expression(&call.function)?;
let mut arguments = vec![];
@ -289,11 +273,11 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
arguments.push(self.reduce_expression(argument)?);
}
self.reducer.reduce_call(call, function, arguments, self.in_circuit)
self.reducer.reduce_call(call, function, arguments)
}
// Statements
pub fn reduce_statement(&mut self, statement: &Statement) -> Result<Statement, CanonicalizeError> {
pub fn reduce_statement(&mut self, statement: &Statement) -> Result<Statement, ReducerError> {
let new = match statement {
Statement::Return(return_statement) => Statement::Return(self.reduce_return(&return_statement)?),
Statement::Definition(definition) => Statement::Definition(self.reduce_definition(&definition)?),
@ -305,26 +289,22 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
Statement::Block(block) => Statement::Block(self.reduce_block(&block)?),
};
self.reducer.reduce_statement(statement, new, self.in_circuit)
self.reducer.reduce_statement(statement, new)
}
pub fn reduce_return(&mut self, return_statement: &ReturnStatement) -> Result<ReturnStatement, CanonicalizeError> {
pub fn reduce_return(&mut self, return_statement: &ReturnStatement) -> Result<ReturnStatement, ReducerError> {
let expression = self.reduce_expression(&return_statement.expression)?;
self.reducer
.reduce_return(return_statement, expression, self.in_circuit)
self.reducer.reduce_return(return_statement, expression)
}
pub fn reduce_variable_name(&mut self, variable_name: &VariableName) -> Result<VariableName, CanonicalizeError> {
pub fn reduce_variable_name(&mut self, variable_name: &VariableName) -> Result<VariableName, ReducerError> {
let identifier = self.reduce_identifier(&variable_name.identifier)?;
self.reducer.reduce_variable_name(variable_name, identifier)
}
pub fn reduce_definition(
&mut self,
definition: &DefinitionStatement,
) -> Result<DefinitionStatement, CanonicalizeError> {
pub fn reduce_definition(&mut self, definition: &DefinitionStatement) -> Result<DefinitionStatement, ReducerError> {
let mut variable_names = vec![];
for variable_name in definition.variable_names.iter() {
variable_names.push(self.reduce_variable_name(variable_name)?);
@ -338,11 +318,10 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
let value = self.reduce_expression(&definition.value)?;
self.reducer
.reduce_definition(definition, variable_names, type_, value, self.in_circuit)
self.reducer.reduce_definition(definition, variable_names, type_, value)
}
pub fn reduce_assignee_access(&mut self, access: &AssigneeAccess) -> Result<AssigneeAccess, CanonicalizeError> {
pub fn reduce_assignee_access(&mut self, access: &AssigneeAccess) -> Result<AssigneeAccess, ReducerError> {
let new = match access {
AssigneeAccess::ArrayRange(left, right) => {
let left = left.as_ref().map(|left| self.reduce_expression(left)).transpose()?;
@ -355,10 +334,10 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
_ => access.clone(),
};
self.reducer.reduce_assignee_access(access, new, self.in_circuit)
self.reducer.reduce_assignee_access(access, new)
}
pub fn reduce_assignee(&mut self, assignee: &Assignee) -> Result<Assignee, CanonicalizeError> {
pub fn reduce_assignee(&mut self, assignee: &Assignee) -> Result<Assignee, ReducerError> {
let identifier = self.reduce_identifier(&assignee.identifier)?;
let mut accesses = vec![];
@ -366,21 +345,20 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
accesses.push(self.reduce_assignee_access(access)?);
}
self.reducer
.reduce_assignee(assignee, identifier, accesses, self.in_circuit)
self.reducer.reduce_assignee(assignee, identifier, accesses)
}
pub fn reduce_assign(&mut self, assign: &AssignStatement) -> Result<AssignStatement, CanonicalizeError> {
pub fn reduce_assign(&mut self, assign: &AssignStatement) -> Result<AssignStatement, ReducerError> {
let assignee = self.reduce_assignee(&assign.assignee)?;
let value = self.reduce_expression(&assign.value)?;
self.reducer.reduce_assign(assign, assignee, value, self.in_circuit)
self.reducer.reduce_assign(assign, assignee, value)
}
pub fn reduce_conditional(
&mut self,
conditional: &ConditionalStatement,
) -> Result<ConditionalStatement, CanonicalizeError> {
) -> Result<ConditionalStatement, ReducerError> {
let condition = self.reduce_expression(&conditional.condition)?;
let block = self.reduce_block(&conditional.block)?;
let next = conditional
@ -389,27 +367,22 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
.map(|condition| self.reduce_statement(condition))
.transpose()?;
self.reducer
.reduce_conditional(conditional, condition, block, next, self.in_circuit)
self.reducer.reduce_conditional(conditional, condition, block, next)
}
pub fn reduce_iteration(
&mut self,
iteration: &IterationStatement,
) -> Result<IterationStatement, CanonicalizeError> {
pub fn reduce_iteration(&mut self, iteration: &IterationStatement) -> Result<IterationStatement, ReducerError> {
let variable = self.reduce_identifier(&iteration.variable)?;
let start = self.reduce_expression(&iteration.start)?;
let stop = self.reduce_expression(&iteration.stop)?;
let block = self.reduce_block(&iteration.block)?;
self.reducer
.reduce_iteration(iteration, variable, start, stop, block, self.in_circuit)
self.reducer.reduce_iteration(iteration, variable, start, stop, block)
}
pub fn reduce_console(
&mut self,
console_function_call: &ConsoleStatement,
) -> Result<ConsoleStatement, CanonicalizeError> {
) -> Result<ConsoleStatement, ReducerError> {
let function = match &console_function_call.function {
ConsoleFunction::Assert(expression) => ConsoleFunction::Assert(self.reduce_expression(expression)?),
ConsoleFunction::Debug(format) | ConsoleFunction::Error(format) | ConsoleFunction::Log(format) => {
@ -428,35 +401,33 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
ConsoleFunction::Debug(_) => ConsoleFunction::Debug(formatted),
ConsoleFunction::Error(_) => ConsoleFunction::Error(formatted),
ConsoleFunction::Log(_) => ConsoleFunction::Log(formatted),
_ => unimplemented!(), // impossible
_ => return Err(ReducerError::impossible_console_assert_call(&format.span)),
}
}
};
self.reducer
.reduce_console(console_function_call, function, self.in_circuit)
self.reducer.reduce_console(console_function_call, function)
}
pub fn reduce_expression_statement(
&mut self,
expression: &ExpressionStatement,
) -> Result<ExpressionStatement, CanonicalizeError> {
) -> Result<ExpressionStatement, ReducerError> {
let inner_expression = self.reduce_expression(&expression.expression)?;
self.reducer
.reduce_expression_statement(expression, inner_expression, self.in_circuit)
self.reducer.reduce_expression_statement(expression, inner_expression)
}
pub fn reduce_block(&mut self, block: &Block) -> Result<Block, CanonicalizeError> {
pub fn reduce_block(&mut self, block: &Block) -> Result<Block, ReducerError> {
let mut statements = vec![];
for statement in block.statements.iter() {
statements.push(self.reduce_statement(statement)?);
}
self.reducer.reduce_block(block, statements, self.in_circuit)
self.reducer.reduce_block(block, statements)
}
// Program
pub fn reduce_program(&mut self, program: &Program) -> Result<Program, CanonicalizeError> {
pub fn reduce_program(&mut self, program: &Program) -> Result<Program, ReducerError> {
let mut inputs = vec![];
for input in program.expected_input.iter() {
inputs.push(self.reduce_function_input(input)?);
@ -468,9 +439,11 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
}
let mut circuits = IndexMap::new();
self.reducer.swap_in_circuit();
for (identifier, circuit) in program.circuits.iter() {
circuits.insert(self.reduce_identifier(identifier)?, self.reduce_circuit(circuit)?);
}
self.reducer.swap_in_circuit();
let mut functions = IndexMap::new();
for (identifier, function) in program.functions.iter() {
@ -484,15 +457,14 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
pub fn reduce_function_input_variable(
&mut self,
variable: &FunctionInputVariable,
) -> Result<FunctionInputVariable, CanonicalizeError> {
) -> Result<FunctionInputVariable, ReducerError> {
let identifier = self.reduce_identifier(&variable.identifier)?;
let type_ = self.reduce_type(&variable.type_, &variable.span)?;
self.reducer
.reduce_function_input_variable(variable, identifier, type_, self.in_circuit)
self.reducer.reduce_function_input_variable(variable, identifier, type_)
}
pub fn reduce_function_input(&mut self, input: &FunctionInput) -> Result<FunctionInput, CanonicalizeError> {
pub fn reduce_function_input(&mut self, input: &FunctionInput) -> Result<FunctionInput, ReducerError> {
let new = match input {
FunctionInput::Variable(function_input_variable) => {
FunctionInput::Variable(self.reduce_function_input_variable(function_input_variable)?)
@ -500,13 +472,13 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
_ => input.clone(),
};
self.reducer.reduce_function_input(input, new, self.in_circuit)
self.reducer.reduce_function_input(input, new)
}
pub fn reduce_package_or_packages(
&mut self,
package_or_packages: &PackageOrPackages,
) -> Result<PackageOrPackages, CanonicalizeError> {
) -> Result<PackageOrPackages, ReducerError> {
let new = match package_or_packages {
PackageOrPackages::Package(package) => PackageOrPackages::Package(Package {
name: self.reduce_identifier(&package.name)?,
@ -523,17 +495,13 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
self.reducer.reduce_package_or_packages(package_or_packages, new)
}
pub fn reduce_import(&mut self, import: &ImportStatement) -> Result<ImportStatement, CanonicalizeError> {
pub fn reduce_import(&mut self, import: &ImportStatement) -> Result<ImportStatement, ReducerError> {
let package_or_packages = self.reduce_package_or_packages(&import.package_or_packages)?;
self.reducer.reduce_import(import, package_or_packages)
}
pub fn reduce_circuit_member(
&mut self,
circuit_member: &CircuitMember,
) -> Result<CircuitMember, CanonicalizeError> {
self.in_circuit = !self.in_circuit;
pub fn reduce_circuit_member(&mut self, circuit_member: &CircuitMember) -> Result<CircuitMember, ReducerError> {
let new = match circuit_member {
CircuitMember::CircuitVariable(identifier, type_) => CircuitMember::CircuitVariable(
self.reduce_identifier(&identifier)?,
@ -543,12 +511,11 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
CircuitMember::CircuitFunction(self.reduce_function(&function)?)
}
};
self.in_circuit = !self.in_circuit;
self.reducer.reduce_circuit_member(circuit_member, new)
}
pub fn reduce_circuit(&mut self, circuit: &Circuit) -> Result<Circuit, CanonicalizeError> {
pub fn reduce_circuit(&mut self, circuit: &Circuit) -> Result<Circuit, ReducerError> {
let circuit_name = self.reduce_identifier(&circuit.circuit_name)?;
let mut members = vec![];
@ -559,13 +526,13 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
self.reducer.reduce_circuit(circuit, circuit_name, members)
}
fn reduce_annotation(&mut self, annotation: &Annotation) -> Result<Annotation, CanonicalizeError> {
fn reduce_annotation(&mut self, annotation: &Annotation) -> Result<Annotation, ReducerError> {
let name = self.reduce_identifier(&annotation.name)?;
self.reducer.reduce_annotation(annotation, name)
}
pub fn reduce_function(&mut self, function: &Function) -> Result<Function, CanonicalizeError> {
pub fn reduce_function(&mut self, function: &Function) -> Result<Function, ReducerError> {
let identifier = self.reduce_identifier(&function.identifier)?;
let mut annotations = vec![];
@ -586,14 +553,7 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
let block = self.reduce_block(&function.block)?;
self.reducer.reduce_function(
function,
identifier,
annotations,
inputs,
output,
block,
self.in_circuit,
)
self.reducer
.reduce_function(function, identifier, annotations, inputs, output, block)
}
}

143
ast/src/reducer/reconstructing_reducer.rs
View File

@ -20,34 +20,26 @@ use indexmap::IndexMap;
// Needed to fix clippy bug.
#[allow(clippy::redundant_closure)]
pub trait ReconstructingReducer {
fn reduce_type(
&mut self,
_type_: &Type,
new: Type,
_in_circuit: bool,
_span: &Span,
) -> Result<Type, CanonicalizeError> {
fn in_circuit(&self) -> bool;
fn swap_in_circuit(&mut self);
fn reduce_type(&mut self, _type_: &Type, new: Type, _span: &Span) -> Result<Type, ReducerError> {
Ok(new)
}
// Expressions
fn reduce_expression(
&mut self,
_expression: &Expression,
new: Expression,
_in_circuit: bool,
) -> Result<Expression, CanonicalizeError> {
fn reduce_expression(&mut self, _expression: &Expression, new: Expression) -> Result<Expression, ReducerError> {
Ok(new)
}
fn reduce_identifier(&mut self, identifier: &Identifier) -> Result<Identifier, CanonicalizeError> {
fn reduce_identifier(&mut self, identifier: &Identifier) -> Result<Identifier, ReducerError> {
Ok(Identifier {
name: identifier.name.clone(),
span: identifier.span.clone(),
})
}
fn reduce_group_tuple(&mut self, group_tuple: &GroupTuple) -> Result<GroupTuple, CanonicalizeError> {
fn reduce_group_tuple(&mut self, group_tuple: &GroupTuple) -> Result<GroupTuple, ReducerError> {
Ok(GroupTuple {
x: group_tuple.x.clone(),
y: group_tuple.y.clone(),
@ -55,11 +47,7 @@ pub trait ReconstructingReducer {
})
}
fn reduce_group_value(
&mut self,
_group_value: &GroupValue,
new: GroupValue,
) -> Result<GroupValue, CanonicalizeError> {
fn reduce_group_value(&mut self, _group_value: &GroupValue, new: GroupValue) -> Result<GroupValue, ReducerError> {
Ok(new)
}
@ -67,7 +55,7 @@ pub trait ReconstructingReducer {
&mut self,
_value: &ValueExpression,
new: ValueExpression,
) -> Result<ValueExpression, CanonicalizeError> {
) -> Result<ValueExpression, ReducerError> {
Ok(new)
}
@ -77,8 +65,7 @@ pub trait ReconstructingReducer {
left: Expression,
right: Expression,
op: BinaryOperation,
_in_circuit: bool,
) -> Result<BinaryExpression, CanonicalizeError> {
) -> Result<BinaryExpression, ReducerError> {
Ok(BinaryExpression {
left: Box::new(left),
right: Box::new(right),
@ -92,8 +79,7 @@ pub trait ReconstructingReducer {
unary: &UnaryExpression,
inner: Expression,
op: UnaryOperation,
_in_circuit: bool,
) -> Result<UnaryExpression, CanonicalizeError> {
) -> Result<UnaryExpression, ReducerError> {
Ok(UnaryExpression {
inner: Box::new(inner),
op,
@ -107,8 +93,7 @@ pub trait ReconstructingReducer {
condition: Expression,
if_true: Expression,
if_false: Expression,
_in_circuit: bool,
) -> Result<TernaryExpression, CanonicalizeError> {
) -> Result<TernaryExpression, ReducerError> {
Ok(TernaryExpression {
condition: Box::new(condition),
if_true: Box::new(if_true),
@ -122,8 +107,7 @@ pub trait ReconstructingReducer {
cast: &CastExpression,
inner: Expression,
target_type: Type,
_in_circuit: bool,
) -> Result<CastExpression, CanonicalizeError> {
) -> Result<CastExpression, ReducerError> {
Ok(CastExpression {
inner: Box::new(inner),
target_type,
@ -135,8 +119,7 @@ pub trait ReconstructingReducer {
&mut self,
array_inline: &ArrayInlineExpression,
elements: Vec<SpreadOrExpression>,
_in_circuit: bool,
) -> Result<ArrayInlineExpression, CanonicalizeError> {
) -> Result<ArrayInlineExpression, ReducerError> {
Ok(ArrayInlineExpression {
elements,
span: array_inline.span.clone(),
@ -147,8 +130,7 @@ pub trait ReconstructingReducer {
&mut self,
array_init: &ArrayInitExpression,
element: Expression,
_in_circuit: bool,
) -> Result<ArrayInitExpression, CanonicalizeError> {
) -> Result<ArrayInitExpression, ReducerError> {
Ok(ArrayInitExpression {
element: Box::new(element),
dimensions: array_init.dimensions.clone(),
@ -161,8 +143,7 @@ pub trait ReconstructingReducer {
array_access: &ArrayAccessExpression,
array: Expression,
index: Expression,
_in_circuit: bool,
) -> Result<ArrayAccessExpression, CanonicalizeError> {
) -> Result<ArrayAccessExpression, ReducerError> {
Ok(ArrayAccessExpression {
array: Box::new(array),
index: Box::new(index),
@ -176,8 +157,7 @@ pub trait ReconstructingReducer {
array: Expression,
left: Option<Expression>,
right: Option<Expression>,
_in_circuit: bool,
) -> Result<ArrayRangeAccessExpression, CanonicalizeError> {
) -> Result<ArrayRangeAccessExpression, ReducerError> {
Ok(ArrayRangeAccessExpression {
array: Box::new(array),
left: left.map(|expr| Box::new(expr)),
@ -190,8 +170,7 @@ pub trait ReconstructingReducer {
&mut self,
tuple_init: &TupleInitExpression,
elements: Vec<Expression>,
_in_circuit: bool,
) -> Result<TupleInitExpression, CanonicalizeError> {
) -> Result<TupleInitExpression, ReducerError> {
Ok(TupleInitExpression {
elements,
span: tuple_init.span.clone(),
@ -202,8 +181,7 @@ pub trait ReconstructingReducer {
&mut self,
tuple_access: &TupleAccessExpression,
tuple: Expression,
_in_circuit: bool,
) -> Result<TupleAccessExpression, CanonicalizeError> {
) -> Result<TupleAccessExpression, ReducerError> {
Ok(TupleAccessExpression {
tuple: Box::new(tuple),
index: tuple_access.index.clone(),
@ -216,8 +194,7 @@ pub trait ReconstructingReducer {
_variable: &CircuitImpliedVariableDefinition,
identifier: Identifier,
expression: Option<Expression>,
_in_circuit: bool,
) -> Result<CircuitImpliedVariableDefinition, CanonicalizeError> {
) -> Result<CircuitImpliedVariableDefinition, ReducerError> {
Ok(CircuitImpliedVariableDefinition { identifier, expression })
}
@ -226,8 +203,7 @@ pub trait ReconstructingReducer {
circuit_init: &CircuitInitExpression,
name: Identifier,
members: Vec<CircuitImpliedVariableDefinition>,
_in_circuit: bool,
) -> Result<CircuitInitExpression, CanonicalizeError> {
) -> Result<CircuitInitExpression, ReducerError> {
Ok(CircuitInitExpression {
name,
members,
@ -240,8 +216,7 @@ pub trait ReconstructingReducer {
circuit_member_access: &CircuitMemberAccessExpression,
circuit: Expression,
name: Identifier,
_in_circuit: bool,
) -> Result<CircuitMemberAccessExpression, CanonicalizeError> {
) -> Result<CircuitMemberAccessExpression, ReducerError> {
Ok(CircuitMemberAccessExpression {
circuit: Box::new(circuit),
name,
@ -254,8 +229,7 @@ pub trait ReconstructingReducer {
circuit_static_fn_access: &CircuitStaticFunctionAccessExpression,
circuit: Expression,
name: Identifier,
_in_circuit: bool,
) -> Result<CircuitStaticFunctionAccessExpression, CanonicalizeError> {
) -> Result<CircuitStaticFunctionAccessExpression, ReducerError> {
Ok(CircuitStaticFunctionAccessExpression {
circuit: Box::new(circuit),
name,
@ -268,8 +242,7 @@ pub trait ReconstructingReducer {
call: &CallExpression,
function: Expression,
arguments: Vec<Expression>,
_in_circuit: bool,
) -> Result<CallExpression, CanonicalizeError> {
) -> Result<CallExpression, ReducerError> {
Ok(CallExpression {
function: Box::new(function),
arguments,
@ -278,12 +251,7 @@ pub trait ReconstructingReducer {
}
// Statements
fn reduce_statement(
&mut self,
_statement: &Statement,
new: Statement,
_in_circuit: bool,
) -> Result<Statement, CanonicalizeError> {
fn reduce_statement(&mut self, _statement: &Statement, new: Statement) -> Result<Statement, ReducerError> {
Ok(new)
}
@ -291,8 +259,7 @@ pub trait ReconstructingReducer {
&mut self,
return_statement: &ReturnStatement,
expression: Expression,
_in_circuit: bool,
) -> Result<ReturnStatement, CanonicalizeError> {
) -> Result<ReturnStatement, ReducerError> {
Ok(ReturnStatement {
expression,
span: return_statement.span.clone(),
@ -303,7 +270,7 @@ pub trait ReconstructingReducer {
&mut self,
variable_name: &VariableName,
identifier: Identifier,
) -> Result<VariableName, CanonicalizeError> {
) -> Result<VariableName, ReducerError> {
Ok(VariableName {
mutable: variable_name.mutable,
identifier,
@ -317,8 +284,7 @@ pub trait ReconstructingReducer {
variable_names: Vec<VariableName>,
type_: Option<Type>,
value: Expression,
_in_circuit: bool,
) -> Result<DefinitionStatement, CanonicalizeError> {
) -> Result<DefinitionStatement, ReducerError> {
Ok(DefinitionStatement {
declaration_type: definition.declaration_type.clone(),
variable_names,
@ -332,8 +298,7 @@ pub trait ReconstructingReducer {
&mut self,
_access: &AssigneeAccess,
new: AssigneeAccess,
_in_circuit: bool,
) -> Result<AssigneeAccess, CanonicalizeError> {
) -> Result<AssigneeAccess, ReducerError> {
Ok(new)
}
@ -342,8 +307,7 @@ pub trait ReconstructingReducer {
assignee: &Assignee,
identifier: Identifier,
accesses: Vec<AssigneeAccess>,
_in_circuit: bool,
) -> Result<Assignee, CanonicalizeError> {
) -> Result<Assignee, ReducerError> {
Ok(Assignee {
identifier,
accesses,
@ -356,8 +320,7 @@ pub trait ReconstructingReducer {
assign: &AssignStatement,
assignee: Assignee,
value: Expression,
_in_circuit: bool,
) -> Result<AssignStatement, CanonicalizeError> {
) -> Result<AssignStatement, ReducerError> {
Ok(AssignStatement {
operation: assign.operation.clone(),
assignee,
@ -372,8 +335,7 @@ pub trait ReconstructingReducer {
condition: Expression,
block: Block,
statement: Option<Statement>,
_in_circuit: bool,
) -> Result<ConditionalStatement, CanonicalizeError> {
) -> Result<ConditionalStatement, ReducerError> {
Ok(ConditionalStatement {
condition,
block,
@ -389,8 +351,7 @@ pub trait ReconstructingReducer {
start: Expression,
stop: Expression,
block: Block,
_in_circuit: bool,
) -> Result<IterationStatement, CanonicalizeError> {
) -> Result<IterationStatement, ReducerError> {
Ok(IterationStatement {
variable,
start,
@ -404,8 +365,7 @@ pub trait ReconstructingReducer {
&mut self,
console: &ConsoleStatement,
function: ConsoleFunction,
_in_circuit: bool,
) -> Result<ConsoleStatement, CanonicalizeError> {
) -> Result<ConsoleStatement, ReducerError> {
Ok(ConsoleStatement {
function,
span: console.span.clone(),
@ -416,20 +376,14 @@ pub trait ReconstructingReducer {
&mut self,
expression_statement: &ExpressionStatement,
expression: Expression,
_in_circuit: bool,
) -> Result<ExpressionStatement, CanonicalizeError> {
) -> Result<ExpressionStatement, ReducerError> {
Ok(ExpressionStatement {
expression,
span: expression_statement.span.clone(),
})
}
fn reduce_block(
&mut self,
block: &Block,
statements: Vec<Statement>,
_in_circuit: bool,
) -> Result<Block, CanonicalizeError> {
fn reduce_block(&mut self, block: &Block, statements: Vec<Statement>) -> Result<Block, ReducerError> {
Ok(Block {
statements,
span: block.span.clone(),
@ -444,7 +398,7 @@ pub trait ReconstructingReducer {
imports: Vec<ImportStatement>,
circuits: IndexMap<Identifier, Circuit>,
functions: IndexMap<Identifier, Function>,
) -> Result<Program, CanonicalizeError> {
) -> Result<Program, ReducerError> {
Ok(Program {
name: program.name.clone(),
expected_input,
@ -459,8 +413,7 @@ pub trait ReconstructingReducer {
variable: &FunctionInputVariable,
identifier: Identifier,
type_: Type,
_in_circuit: bool,
) -> Result<FunctionInputVariable, CanonicalizeError> {
) -> Result<FunctionInputVariable, ReducerError> {
Ok(FunctionInputVariable {
identifier,
const_: variable.const_,
@ -474,8 +427,7 @@ pub trait ReconstructingReducer {
&mut self,
_input: &FunctionInput,
new: FunctionInput,
_in_circuit: bool,
) -> Result<FunctionInput, CanonicalizeError> {
) -> Result<FunctionInput, ReducerError> {
Ok(new)
}
@ -483,7 +435,7 @@ pub trait ReconstructingReducer {
&mut self,
_package_or_packages: &PackageOrPackages,
new: PackageOrPackages,
) -> Result<PackageOrPackages, CanonicalizeError> {
) -> Result<PackageOrPackages, ReducerError> {
Ok(new)
}
@ -491,7 +443,7 @@ pub trait ReconstructingReducer {
&mut self,
import: &ImportStatement,
package_or_packages: PackageOrPackages,
) -> Result<ImportStatement, CanonicalizeError> {
) -> Result<ImportStatement, ReducerError> {
Ok(ImportStatement {
package_or_packages,
span: import.span.clone(),
@ -502,7 +454,7 @@ pub trait ReconstructingReducer {
&mut self,
_circuit_member: &CircuitMember,
new: CircuitMember,
) -> Result<CircuitMember, CanonicalizeError> {
) -> Result<CircuitMember, ReducerError> {
Ok(new)
}
@ -511,15 +463,11 @@ pub trait ReconstructingReducer {
_circuit: &Circuit,
circuit_name: Identifier,
members: Vec<CircuitMember>,
) -> Result<Circuit, CanonicalizeError> {
) -> Result<Circuit, ReducerError> {
Ok(Circuit { circuit_name, members })
}
fn reduce_annotation(
&mut self,
annotation: &Annotation,
name: Identifier,
) -> Result<Annotation, CanonicalizeError> {
fn reduce_annotation(&mut self, annotation: &Annotation, name: Identifier) -> Result<Annotation, ReducerError> {
Ok(Annotation {
span: annotation.span.clone(),
name,
@ -536,8 +484,7 @@ pub trait ReconstructingReducer {
input: Vec<FunctionInput>,
output: Option<Type>,
block: Block,
_in_circuit: bool,
) -> Result<Function, CanonicalizeError> {
) -> Result<Function, ReducerError> {
Ok(Function {
identifier,
annotations,

3
compiler/Cargo.toml
View File

@ -49,6 +49,9 @@ version = "1.4.0"
path = "../asg-passes"
version = "1.4.0"
[dependencies.tendril]
version = "0.4"
[dependencies.snarkvm-curves]
version = "0.2.2"
default-features = false

1
compiler/src/compiler.rs
View File

@ -216,6 +216,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> Compiler<'a, F, G> {
// Use the parser to construct the abstract syntax tree (ast).
let mut ast = parse_ast(self.main_file_path.to_str().unwrap_or_default(), program_string)?;
// Preform compiler optimization via canonicalizing AST if its enabled.
if self.options.canonicalization_enabled {
ast.canonicalize()?;

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

@ -16,7 +16,7 @@
use crate::errors::FunctionError;
use leo_asg::{AsgConvertError, FormattedError};
use leo_ast::{CanonicalizeError, LeoError};
use leo_ast::{LeoError, ReducerError};
use leo_input::InputParserError;
use leo_parser::SyntaxError;
use leo_state::LocalDataVerificationError;
@ -56,7 +56,7 @@ pub enum CompilerError {
AsgConvertError(#[from] AsgConvertError),
#[error("{}", _0)]
CanonicalizeError(#[from] CanonicalizeError),
ReducerError(#[from] ReducerError),
}
impl LeoError for CompilerError {}

7
compiler/src/lib.rs
View File

@ -57,8 +57,11 @@ pub use prelude::*;
pub mod value;
pub use value::*;
pub mod stage;
pub use stage::*;
pub mod phase;
pub use phase::*;
pub mod phases;
pub use phases::*;
pub mod option;
pub use option::*;

2
compiler/src/stage.rs → compiler/src/phase.rs
View File

@ -16,6 +16,6 @@
use leo_asg::Program;
pub trait ASGStage {
pub trait ASGPhase {
fn apply(asg: &mut Program);
}

23
compiler/src/phases/mod.rs Normal file
View File

@ -0,0 +1,23 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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/>.
//! Compiles a Leo program from a file path.
pub mod reducing_director;
pub use reducing_director::*;
pub mod phase;
pub use phase::*;

65
compiler/src/phases/phase.rs Normal file
View File

@ -0,0 +1,65 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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/>.
//! Compiles a Leo program from a file path.
use crate::{CombineAstAsgDirector, CombinerOptions};
use leo_asg::Program as AsgProgram;
use leo_ast::{Ast, Program as AstProgram, ReconstructingReducer, ReducerError};
macro_rules! phase {
($phase_name:ident, $function:item) => {
pub struct $phase_name {
in_circuit: bool,
}
pub struct Options;
impl CombinerOptions for Options {
$function
}
impl ReconstructingReducer for $phase_name {
fn in_circuit(&self) -> bool {
self.in_circuit
}
fn swap_in_circuit(&mut self) {
self.in_circuit = !self.in_circuit;
}
}
impl Default for $phase_name {
fn default() -> Self {
Self { in_circuit: false }
}
}
impl $phase_name {
pub fn phase_ast(&self, ast: &AstProgram, asg: &AsgProgram) -> Result<Ast, ReducerError> {
Ok(Ast::new(CombineAstAsgDirector::new(Self::default(), Options{})
.reduce_program(ast, asg)?))
}
}
};
}
phase!(
TypeInferencePhase,
fn type_inference_enabled(&self) -> bool {
true
}
);

775
compiler/src/phases/reducing_director.rs Normal file
View File

@ -0,0 +1,775 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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/>.
//! Compiles a Leo program from a file path.
use indexmap::IndexMap;
use leo_asg::{
ArrayAccessExpression as AsgArrayAccessExpression,
ArrayInitExpression as AsgArrayInitExpression,
ArrayInlineExpression as AsgArrayInlineExpression,
ArrayRangeAccessExpression as AsgArrayRangeAccessExpression,
AssignAccess as AsgAssignAccess,
AssignStatement as AsgAssignStatement,
BinaryExpression as AsgBinaryExpression,
BlockStatement as AsgBlockStatement,
CallExpression as AsgCallExpression,
CastExpression as AsgCastExpression,
Circuit as AsgCircuit,
CircuitAccessExpression as AsgCircuitAccessExpression,
CircuitInitExpression as AsgCircuitInitExpression,
CircuitMember as AsgCircuitMember,
ConditionalStatement as AsgConditionalStatement,
ConsoleFunction as AsgConsoleFunction,
ConsoleStatement as AsgConsoleStatement,
ConstValue,
Constant as AsgConstant,
DefinitionStatement as AsgDefinitionStatement,
Expression as AsgExpression,
ExpressionStatement as AsgExpressionStatement,
Function as AsgFunction,
GroupValue as AsgGroupValue,
IterationStatement as AsgIterationStatement,
ReturnStatement as AsgReturnStatement,
Statement as AsgStatement,
TernaryExpression as AsgTernaryExpression,
TupleAccessExpression as AsgTupleAccessExpression,
TupleInitExpression as AsgTupleInitExpression,
Type as AsgType,
UnaryExpression as AsgUnaryExpression,
VariableRef as AsgVariableRef,
};
use leo_ast::{
ArrayAccessExpression as AstArrayAccessExpression,
ArrayDimensions,
ArrayInitExpression as AstArrayInitExpression,
ArrayInlineExpression as AstArrayInlineExpression,
ArrayRangeAccessExpression as AstArrayRangeAccessExpression,
AssignStatement as AstAssignStatement,
Assignee,
AssigneeAccess as AstAssignAccess,
BinaryExpression as AstBinaryExpression,
Block as AstBlockStatement,
CallExpression as AstCallExpression,
CastExpression as AstCastExpression,
Circuit as AstCircuit,
CircuitImpliedVariableDefinition,
CircuitInitExpression as AstCircuitInitExpression,
CircuitMember as AstCircuitMember,
CircuitMemberAccessExpression,
CircuitStaticFunctionAccessExpression,
CombinerError,
ConditionalStatement as AstConditionalStatement,
ConsoleFunction as AstConsoleFunction,
ConsoleStatement as AstConsoleStatement,
DefinitionStatement as AstDefinitionStatement,
Expression as AstExpression,
ExpressionStatement as AstExpressionStatement,
FormatString,
Function as AstFunction,
GroupTuple,
GroupValue as AstGroupValue,
IterationStatement as AstIterationStatement,
PositiveNumber,
ReconstructingReducer,
ReducerError,
ReturnStatement as AstReturnStatement,
Span,
SpreadOrExpression,
Statement as AstStatement,
TernaryExpression as AstTernaryExpression,
TupleAccessExpression as AstTupleAccessExpression,
TupleInitExpression as AstTupleInitExpression,
Type as AstType,
UnaryExpression as AstUnaryExpression,
ValueExpression,
};
use tendril::StrTendril;
pub trait CombinerOptions {
fn type_inference_enabled(&self) -> bool {
false
}
}
pub struct CombineAstAsgDirector<R: ReconstructingReducer, O: CombinerOptions> {
ast_reducer: R,
options: O,
}
impl<R: ReconstructingReducer, O: CombinerOptions> CombineAstAsgDirector<R, O> {
pub fn new(ast_reducer: R, options: O) -> Self {
Self { ast_reducer, options }
}
pub fn reduce_type(&mut self, ast: &AstType, asg: &AsgType, span: &Span) -> Result<AstType, ReducerError> {
let new = match (ast, asg) {
(AstType::Array(ast_type, ast_dimensions), AsgType::Array(asg_type, asg_dimensions)) => {
if self.options.type_inference_enabled() {
AstType::Array(
Box::new(self.reduce_type(ast_type, asg_type, span)?),
ArrayDimensions(vec![PositiveNumber {
value: StrTendril::from(format!("{}", asg_dimensions)),
}]),
)
} else {
AstType::Array(
Box::new(self.reduce_type(ast_type, asg_type, span)?),
ast_dimensions.clone(),
)
}
}
(AstType::Tuple(ast_types), AsgType::Tuple(asg_types)) => {
let mut reduced_types = vec![];
for (ast_type, asg_type) in ast_types.iter().zip(asg_types) {
reduced_types.push(self.reduce_type(ast_type, asg_type, span)?);
}
AstType::Tuple(reduced_types)
}
_ => ast.clone(),
};
self.ast_reducer.reduce_type(ast, new, span)
}
pub fn reduce_expression(
&mut self,
ast: &AstExpression,
asg: &AsgExpression,
) -> Result<AstExpression, ReducerError> {
let new = match (ast, asg) {
(AstExpression::Value(value), AsgExpression::Constant(const_)) => {
AstExpression::Value(self.reduce_value(&value, &const_)?)
}
(AstExpression::Binary(ast), AsgExpression::Binary(asg)) => {
AstExpression::Binary(self.reduce_binary(&ast, &asg)?)
}
(AstExpression::Unary(ast), AsgExpression::Unary(asg)) => {
AstExpression::Unary(self.reduce_unary(&ast, &asg)?)
}
(AstExpression::Ternary(ast), AsgExpression::Ternary(asg)) => {
AstExpression::Ternary(self.reduce_ternary(&ast, &asg)?)
}
(AstExpression::Cast(ast), AsgExpression::Cast(asg)) => AstExpression::Cast(self.reduce_cast(&ast, &asg)?),
(AstExpression::ArrayInline(ast), AsgExpression::ArrayInline(asg)) => {
AstExpression::ArrayInline(self.reduce_array_inline(&ast, &asg)?)
}
(AstExpression::ArrayInit(ast), AsgExpression::ArrayInit(asg)) => {
AstExpression::ArrayInit(self.reduce_array_init(&ast, &asg)?)
}
(AstExpression::ArrayAccess(ast), AsgExpression::ArrayAccess(asg)) => {
AstExpression::ArrayAccess(self.reduce_array_access(&ast, &asg)?)
}
(AstExpression::ArrayRangeAccess(ast), AsgExpression::ArrayRangeAccess(asg)) => {
AstExpression::ArrayRangeAccess(self.reduce_array_range_access(&ast, &asg)?)
}
(AstExpression::TupleInit(ast), AsgExpression::TupleInit(asg)) => {
AstExpression::TupleInit(self.reduce_tuple_init(&ast, &asg)?)
}
(AstExpression::TupleAccess(ast), AsgExpression::TupleAccess(asg)) => {
AstExpression::TupleAccess(self.reduce_tuple_access(&ast, &asg)?)
}
(AstExpression::CircuitInit(ast), AsgExpression::CircuitInit(asg)) => {
AstExpression::CircuitInit(self.reduce_circuit_init(&ast, &asg)?)
}
(AstExpression::CircuitMemberAccess(ast), AsgExpression::CircuitAccess(asg)) => {
AstExpression::CircuitMemberAccess(self.reduce_circuit_member_access(&ast, &asg)?)
}
(AstExpression::CircuitStaticFunctionAccess(ast), AsgExpression::CircuitAccess(asg)) => {
AstExpression::CircuitStaticFunctionAccess(self.reduce_circuit_static_fn_access(&ast, &asg)?)
}
(AstExpression::Call(ast), AsgExpression::Call(asg)) => AstExpression::Call(self.reduce_call(&ast, &asg)?),
_ => ast.clone(),
};
self.ast_reducer.reduce_expression(ast, new)
}
pub fn reduce_array_access(
&mut self,
ast: &AstArrayAccessExpression,
asg: &AsgArrayAccessExpression,
) -> Result<AstArrayAccessExpression, ReducerError> {
let array = self.reduce_expression(&ast.array, asg.array.get())?;
let index = self.reduce_expression(&ast.index, asg.index.get())?;
self.ast_reducer.reduce_array_access(ast, array, index)
}
pub fn reduce_array_init(
&mut self,
ast: &AstArrayInitExpression,
asg: &AsgArrayInitExpression,
) -> Result<AstArrayInitExpression, ReducerError> {
let element = self.reduce_expression(&ast.element, asg.element.get())?;
self.ast_reducer.reduce_array_init(ast, element)
}
pub fn reduce_array_inline(
&mut self,
ast: &AstArrayInlineExpression,
asg: &AsgArrayInlineExpression,
) -> Result<AstArrayInlineExpression, ReducerError> {
let mut elements = vec![];
for (ast_element, asg_element) in ast.elements.iter().zip(asg.elements.iter()) {
let reduced_element = match ast_element {
SpreadOrExpression::Expression(ast_expression) => {
SpreadOrExpression::Expression(self.reduce_expression(ast_expression, asg_element.0.get())?)
}
SpreadOrExpression::Spread(ast_expression) => {
SpreadOrExpression::Spread(self.reduce_expression(ast_expression, asg_element.0.get())?)
}
};
elements.push(reduced_element);
}
self.ast_reducer.reduce_array_inline(ast, elements)
}
pub fn reduce_array_range_access(
&mut self,
ast: &AstArrayRangeAccessExpression,
asg: &AsgArrayRangeAccessExpression,
) -> Result<AstArrayRangeAccessExpression, ReducerError> {
let array = self.reduce_expression(&ast.array, asg.array.get())?;
let left = match (ast.left.as_ref(), asg.left.get()) {
(Some(ast_left), Some(asg_left)) => Some(self.reduce_expression(ast_left, asg_left)?),
_ => None,
};
let right = match (ast.right.as_ref(), asg.right.get()) {
(Some(ast_right), Some(asg_right)) => Some(self.reduce_expression(ast_right, asg_right)?),
_ => None,
};
self.ast_reducer.reduce_array_range_access(ast, array, left, right)
}
pub fn reduce_binary(
&mut self,
ast: &AstBinaryExpression,
asg: &AsgBinaryExpression,
) -> Result<AstBinaryExpression, ReducerError> {
let left = self.reduce_expression(&ast.left, asg.left.get())?;
let right = self.reduce_expression(&ast.right, asg.right.get())?;
self.ast_reducer.reduce_binary(ast, left, right, ast.op.clone())
}
pub fn reduce_call(
&mut self,
ast: &AstCallExpression,
asg: &AsgCallExpression,
) -> Result<AstCallExpression, ReducerError> {
// TODO FIGURE IT OUT
// let function = self.reduce_expression(&ast.function, asg.function.get())?;
// let target = asg.target.get().map(|exp| self.reduce_expression())
// Is this needed?
let mut arguments = vec![];
for (ast_arg, asg_arg) in ast.arguments.iter().zip(asg.arguments.iter()) {
arguments.push(self.reduce_expression(ast_arg, asg_arg.get())?);
}
self.ast_reducer.reduce_call(ast, *ast.function.clone(), arguments)
}
pub fn reduce_cast(
&mut self,
ast: &AstCastExpression,
asg: &AsgCastExpression,
) -> Result<AstCastExpression, ReducerError> {
let inner = self.reduce_expression(&ast.inner, &asg.inner.get())?;
let target_type = self.reduce_type(&ast.target_type, &asg.target_type, &ast.span)?;
self.ast_reducer.reduce_cast(ast, inner, target_type)
}
pub fn reduce_circuit_member_access(
&mut self,
ast: &CircuitMemberAccessExpression,
_asg: &AsgCircuitAccessExpression,
) -> Result<CircuitMemberAccessExpression, ReducerError> {
// let circuit = self.reduce_expression(&circuit_member_access.circuit)?;
// let name = self.reduce_identifier(&circuit_member_access.name)?;
// let target = input.target.get().map(|e| self.reduce_expression(e));
self.ast_reducer
.reduce_circuit_member_access(ast, *ast.circuit.clone(), ast.name.clone())
}
pub fn reduce_circuit_static_fn_access(
&mut self,
ast: &CircuitStaticFunctionAccessExpression,
_asg: &AsgCircuitAccessExpression,
) -> Result<CircuitStaticFunctionAccessExpression, ReducerError> {
// let circuit = self.reduce_expression(&circuit_member_access.circuit)?;
// let name = self.reduce_identifier(&circuit_member_access.name)?;
// let target = input.target.get().map(|e| self.reduce_expression(e));
self.ast_reducer
.reduce_circuit_static_fn_access(ast, *ast.circuit.clone(), ast.name.clone())
}
pub fn reduce_circuit_implied_variable_definition(
&mut self,
ast: &CircuitImpliedVariableDefinition,
asg: &AsgExpression,
) -> Result<CircuitImpliedVariableDefinition, ReducerError> {
let expression = ast
.expression
.as_ref()
.map(|ast_expr| self.reduce_expression(ast_expr, asg))
.transpose()?;
self.ast_reducer
.reduce_circuit_implied_variable_definition(ast, ast.identifier.clone(), expression)
}
pub fn reduce_circuit_init(
&mut self,
ast: &AstCircuitInitExpression,
asg: &AsgCircuitInitExpression,
) -> Result<AstCircuitInitExpression, ReducerError> {
let mut members = vec![];
for (ast_member, asg_member) in ast.members.iter().zip(asg.values.iter()) {
members.push(self.reduce_circuit_implied_variable_definition(ast_member, asg_member.1.get())?);
}
self.ast_reducer.reduce_circuit_init(ast, ast.name.clone(), members)
}
pub fn reduce_ternary(
&mut self,
ast: &AstTernaryExpression,
asg: &AsgTernaryExpression,
) -> Result<AstTernaryExpression, ReducerError> {
let condition = self.reduce_expression(&ast.condition, asg.condition.get())?;
let if_true = self.reduce_expression(&ast.if_true, asg.if_true.get())?;
let if_false = self.reduce_expression(&ast.if_false, asg.if_false.get())?;
self.ast_reducer.reduce_ternary(ast, condition, if_true, if_false)
}
pub fn reduce_tuple_access(
&mut self,
ast: &AstTupleAccessExpression,
asg: &AsgTupleAccessExpression,
) -> Result<AstTupleAccessExpression, ReducerError> {
let tuple = self.reduce_expression(&ast.tuple, asg.tuple_ref.get())?;
self.ast_reducer.reduce_tuple_access(ast, tuple)
}
pub fn reduce_tuple_init(
&mut self,
ast: &AstTupleInitExpression,
asg: &AsgTupleInitExpression,
) -> Result<AstTupleInitExpression, ReducerError> {
let mut elements = vec![];
for (ast_element, asg_element) in ast.elements.iter().zip(asg.elements.iter()) {
let element = self.reduce_expression(ast_element, asg_element.get())?;
elements.push(element);
}
self.ast_reducer.reduce_tuple_init(ast, elements)
}
pub fn reduce_unary(
&mut self,
ast: &AstUnaryExpression,
asg: &AsgUnaryExpression,
) -> Result<AstUnaryExpression, ReducerError> {
let inner = self.reduce_expression(&ast.inner, asg.inner.get())?;
self.ast_reducer.reduce_unary(ast, inner, ast.op.clone())
}
pub fn reduce_value(&mut self, ast: &ValueExpression, asg: &AsgConstant) -> Result<ValueExpression, ReducerError> {
let mut new = ast.clone();
if self.options.type_inference_enabled() {
if let ValueExpression::Implicit(tendril, span) = ast {
match &asg.value {
ConstValue::Int(int) => {
new = ValueExpression::Integer(int.get_int_type(), tendril.clone(), span.clone());
}
ConstValue::Group(group) => {
let group_value = match group {
AsgGroupValue::Single(_) => AstGroupValue::Single(tendril.clone(), span.clone()),
AsgGroupValue::Tuple(x, y) => AstGroupValue::Tuple(GroupTuple {
x: x.into(),
y: y.into(),
span: span.clone(),
}),
};
new = ValueExpression::Group(Box::new(group_value));
}
ConstValue::Field(_) => {
new = ValueExpression::Field(tendril.clone(), span.clone());
}
ConstValue::Address(_) => {
new = ValueExpression::Address(tendril.clone(), span.clone());
}
ConstValue::Boolean(_) => {
new = ValueExpression::Boolean(tendril.clone(), span.clone());
}
_ => unimplemented!(), // impossible?
}
}
}
self.ast_reducer.reduce_value(ast, new)
}
pub fn reduce_variable_ref(
&mut self,
ast: &ValueExpression,
_asg: &AsgVariableRef,
) -> Result<ValueExpression, ReducerError> {
// TODO FIGURE IT OUT
let new = match ast {
// ValueExpression::Group(group_value) => {
// ValueExpression::Group(Box::new(self.reduce_group_value(&group_value)?))
// }
_ => ast.clone(),
};
Ok(new)
// self.ast_reducer.reduce_value(value, new)
}
pub fn reduce_statement(
&mut self,
ast_statement: &AstStatement,
asg_statement: &AsgStatement,
) -> Result<AstStatement, ReducerError> {
let new = match (ast_statement, asg_statement) {
(AstStatement::Assign(ast), AsgStatement::Assign(asg)) => {
AstStatement::Assign(self.reduce_assign(ast, asg)?)
}
(AstStatement::Block(ast), AsgStatement::Block(asg)) => AstStatement::Block(self.reduce_block(ast, asg)?),
(AstStatement::Conditional(ast), AsgStatement::Conditional(asg)) => {
AstStatement::Conditional(self.reduce_conditional(ast, asg)?)
}
(AstStatement::Console(ast), AsgStatement::Console(asg)) => {
AstStatement::Console(self.reduce_console(ast, asg)?)
}
(AstStatement::Definition(ast), AsgStatement::Definition(asg)) => {
AstStatement::Definition(self.reduce_definition(ast, asg)?)
}
(AstStatement::Expression(ast), AsgStatement::Expression(asg)) => {
AstStatement::Expression(self.reduce_expression_statement(ast, asg)?)
}
(AstStatement::Iteration(ast), AsgStatement::Iteration(asg)) => {
AstStatement::Iteration(self.reduce_iteration(ast, asg)?)
}
(AstStatement::Return(ast), AsgStatement::Return(asg)) => {
AstStatement::Return(self.reduce_return(ast, asg)?)
}
_ => ast_statement.clone(),
};
self.ast_reducer.reduce_statement(ast_statement, new)
}
pub fn reduce_assign_access(
&mut self,
ast: &AstAssignAccess,
asg: &AsgAssignAccess,
) -> Result<AstAssignAccess, ReducerError> {
let new = match (ast, asg) {
(AstAssignAccess::ArrayRange(ast_left, ast_right), AsgAssignAccess::ArrayRange(asg_left, asg_right)) => {
let left = match (ast_left.as_ref(), asg_left.get()) {
(Some(ast_left), Some(asg_left)) => Some(self.reduce_expression(ast_left, asg_left)?),
_ => None,
};
let right = match (ast_right.as_ref(), asg_right.get()) {
(Some(ast_right), Some(asg_right)) => Some(self.reduce_expression(ast_right, asg_right)?),
_ => None,
};
AstAssignAccess::ArrayRange(left, right)
}
(AstAssignAccess::ArrayIndex(ast_index), AsgAssignAccess::ArrayIndex(asg_index)) => {
let index = self.reduce_expression(&ast_index, asg_index.get())?;
AstAssignAccess::ArrayIndex(index)
}
_ => ast.clone(),
};
self.ast_reducer.reduce_assignee_access(ast, new)
}
pub fn reduce_assignee(&mut self, ast: &Assignee, asg: &[AsgAssignAccess]) -> Result<Assignee, ReducerError> {
let mut accesses = vec![];
for (ast_access, asg_access) in ast.accesses.iter().zip(asg) {
accesses.push(self.reduce_assign_access(ast_access, asg_access)?);
}
self.ast_reducer.reduce_assignee(ast, ast.identifier.clone(), accesses)
}
pub fn reduce_assign(
&mut self,
ast: &AstAssignStatement,
asg: &AsgAssignStatement,
) -> Result<AstAssignStatement, ReducerError> {
let assignee = self.reduce_assignee(&ast.assignee, &asg.target_accesses)?;
let value = self.reduce_expression(&ast.value, asg.value.get())?;
self.ast_reducer.reduce_assign(ast, assignee, value)
}
pub fn reduce_block(
&mut self,
ast: &AstBlockStatement,
asg: &AsgBlockStatement,
) -> Result<AstBlockStatement, ReducerError> {
let mut statements = vec![];
for (ast_statement, asg_statement) in ast.statements.iter().zip(asg.statements.iter()) {
statements.push(self.reduce_statement(ast_statement, asg_statement.get())?);
}
self.ast_reducer.reduce_block(ast, statements)
}
pub fn reduce_conditional(
&mut self,
ast: &AstConditionalStatement,
asg: &AsgConditionalStatement,
) -> Result<AstConditionalStatement, ReducerError> {
let condition = self.reduce_expression(&ast.condition, asg.condition.get())?;
let block;
if let AsgStatement::Block(asg_block) = asg.result.get() {
block = self.reduce_block(&ast.block, asg_block)?;
} else {
return Err(ReducerError::from(CombinerError::asg_statement_not_block(
&asg.span.as_ref().unwrap(),
)));
}
let next = match (ast.next.as_ref(), asg.next.get()) {
(Some(ast_next), Some(asg_next)) => Some(self.reduce_statement(ast_next, asg_next)?),
_ => None,
};
self.ast_reducer.reduce_conditional(ast, condition, block, next)
}
pub fn reduce_console(
&mut self,
ast: &AstConsoleStatement,
asg: &AsgConsoleStatement,
) -> Result<AstConsoleStatement, ReducerError> {
let function = match (&ast.function, &asg.function) {
(AstConsoleFunction::Assert(ast_expression), AsgConsoleFunction::Assert(asg_expression)) => {
AstConsoleFunction::Assert(self.reduce_expression(&ast_expression, asg_expression.get())?)
}
(AstConsoleFunction::Debug(ast_format), AsgConsoleFunction::Debug(asg_format))
| (AstConsoleFunction::Error(ast_format), AsgConsoleFunction::Error(asg_format))
| (AstConsoleFunction::Log(ast_format), AsgConsoleFunction::Log(asg_format)) => {
let mut parameters = vec![];
for (ast_parameter, asg_parameter) in ast_format.parameters.iter().zip(asg_format.parameters.iter()) {
parameters.push(self.reduce_expression(&ast_parameter, asg_parameter.get())?);
}
let formatted = FormatString {
parts: ast_format.parts.clone(),
parameters,
span: ast_format.span.clone(),
};
match &ast.function {
AstConsoleFunction::Debug(_) => AstConsoleFunction::Debug(formatted),
AstConsoleFunction::Error(_) => AstConsoleFunction::Error(formatted),
AstConsoleFunction::Log(_) => AstConsoleFunction::Log(formatted),
_ => return Err(ReducerError::impossible_console_assert_call(&ast_format.span)),
}
}
_ => ast.function.clone(),
};
self.ast_reducer.reduce_console(ast, function)
}
pub fn reduce_definition(
&mut self,
ast: &AstDefinitionStatement,
asg: &AsgDefinitionStatement,
) -> Result<AstDefinitionStatement, ReducerError> {
let type_;
if asg.variables.len() > 1 {
let mut types = vec![];
for variable in asg.variables.iter() {
types.push(variable.borrow().type_.clone());
}
let asg_type = AsgType::Tuple(types);
type_ = match &ast.type_ {
Some(ast_type) => Some(self.reduce_type(&ast_type, &asg_type, &ast.span)?),
None if self.options.type_inference_enabled() => Some((&asg_type).into()),
_ => None,
};
} else {
type_ = match &ast.type_ {
Some(ast_type) => {
Some(self.reduce_type(&ast_type, &asg.variables.first().unwrap().borrow().type_, &ast.span)?)
}
None if self.options.type_inference_enabled() => {
Some((&asg.variables.first().unwrap().borrow().type_).into())
}
_ => None,
};
}
let value = self.reduce_expression(&ast.value, asg.value.get())?;
self.ast_reducer
.reduce_definition(ast, ast.variable_names.clone(), type_, value)
}
pub fn reduce_expression_statement(
&mut self,
ast: &AstExpressionStatement,
asg: &AsgExpressionStatement,
) -> Result<AstExpressionStatement, ReducerError> {
let inner_expression = self.reduce_expression(&ast.expression, asg.expression.get())?;
self.ast_reducer.reduce_expression_statement(ast, inner_expression)
}
pub fn reduce_iteration(
&mut self,
ast: &AstIterationStatement,
asg: &AsgIterationStatement,
) -> Result<AstIterationStatement, ReducerError> {
let start = self.reduce_expression(&ast.start, asg.start.get())?;
let stop = self.reduce_expression(&ast.stop, asg.stop.get())?;
let block;
if let AsgStatement::Block(asg_block) = asg.body.get() {
block = self.reduce_block(&ast.block, asg_block)?;
} else {
return Err(ReducerError::from(CombinerError::asg_statement_not_block(
&asg.span.as_ref().unwrap(),
)));
}
self.ast_reducer
.reduce_iteration(ast, ast.variable.clone(), start, stop, block)
}
pub fn reduce_return(
&mut self,
ast: &AstReturnStatement,
asg: &AsgReturnStatement,
) -> Result<AstReturnStatement, ReducerError> {
let expression = self.reduce_expression(&ast.expression, asg.expression.get())?;
self.ast_reducer.reduce_return(ast, expression)
}
pub fn reduce_program(
&mut self,
ast: &leo_ast::Program,
asg: &leo_asg::Program,
) -> Result<leo_ast::Program, leo_ast::ReducerError> {
self.ast_reducer.swap_in_circuit();
let mut circuits = IndexMap::new();
for ((ast_ident, ast_circuit), (_asg_ident, asg_circuit)) in ast.circuits.iter().zip(&asg.circuits) {
circuits.insert(ast_ident.clone(), self.reduce_circuit(ast_circuit, asg_circuit)?);
}
self.ast_reducer.swap_in_circuit();
let mut functions = IndexMap::new();
for ((ast_ident, ast_function), (_asg_ident, asg_function)) in ast.functions.iter().zip(&asg.functions) {
functions.insert(ast_ident.clone(), self.reduce_function(ast_function, asg_function)?);
}
self.ast_reducer.reduce_program(
ast,
ast.expected_input.clone(),
ast.imports.clone(),
circuits,
functions,
)
}
pub fn reduce_function(&mut self, ast: &AstFunction, asg: &AsgFunction) -> Result<AstFunction, ReducerError> {
let output = ast
.output
.as_ref()
.map(|type_| self.reduce_type(type_, &asg.output, &ast.span))
.transpose()?;
let mut statements = vec![];
if let Some(AsgStatement::Block(asg_block)) = asg.body.get() {
for (ast_statement, asg_statement) in ast.block.statements.iter().zip(asg_block.statements.iter()) {
statements.push(self.reduce_statement(ast_statement, asg_statement.get())?);
}
}
let block = AstBlockStatement {
statements,
span: ast.block.span.clone(),
};
self.ast_reducer.reduce_function(
ast,
ast.identifier.clone(),
ast.annotations.clone(),
ast.input.clone(),
output,
block,
)
}
pub fn reduce_circuit_member(
&mut self,
ast: &AstCircuitMember,
asg: &AsgCircuitMember,
) -> Result<AstCircuitMember, ReducerError> {
let new = match (ast, asg) {
(AstCircuitMember::CircuitVariable(identifier, ast_type), AsgCircuitMember::Variable(asg_type)) => {
AstCircuitMember::CircuitVariable(
identifier.clone(),
self.reduce_type(ast_type, asg_type, &identifier.span)?,
)
}
(AstCircuitMember::CircuitFunction(ast_function), AsgCircuitMember::Function(asg_function)) => {
AstCircuitMember::CircuitFunction(self.reduce_function(ast_function, asg_function)?)
}
_ => ast.clone(),
};
self.ast_reducer.reduce_circuit_member(ast, new)
}
pub fn reduce_circuit(&mut self, ast: &AstCircuit, asg: &AsgCircuit) -> Result<AstCircuit, ReducerError> {
let mut members = vec![];
for (ast_member, asg_member) in ast.members.iter().zip(asg.members.borrow().iter()) {
members.push(self.reduce_circuit_member(ast_member, asg_member.1)?);
}
self.ast_reducer.reduce_circuit(ast, ast.circuit_name.clone(), members)
}
}

525
compiler/tests/canonicalization/compound_assignment.json
View File

@ -225,7 +225,9 @@
}
}
],
"type_": null,
"type_": {
"IntegerType": "U32"
},
"value": {
"Value": {
"Integer": [
@ -274,7 +276,8 @@
},
"right": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"20",
{
"line_start": 12,
@ -371,7 +374,18 @@
}
}
],
"type_": null,
"type_": {
"Array": [
{
"IntegerType": "U8"
},
[
{
"value": "2"
}
]
]
},
"value": {
"ArrayInline": {
"elements": [
@ -441,7 +455,8 @@
{
"ArrayIndex": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 16,
@ -474,7 +489,8 @@
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 16,
@ -546,7 +562,8 @@
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 17,
@ -624,7 +641,16 @@
}
}
],
"type_": null,
"type_": {
"Tuple": [
{
"IntegerType": "U8"
},
{
"IntegerType": "U8"
}
]
},
"value": {
"TupleInit": {
"elements": [
@ -847,7 +873,9 @@
}
}
],
"type_": null,
"type_": {
"Circuit": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":12,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit Foo {\\\"}\"}"
},
"value": {
"CircuitInit": {
"name": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":23,\\\"line_stop\\\":23,\\\"col_start\\\":13,\\\"col_stop\\\":16,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" let foo = Foo { f: 6u8, y: (1u8, 1u8) };\\\"}\"}",
@ -1080,18 +1108,245 @@
"variable_names": [
{
"mutable": true,
"identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":27,\\\"line_stop\\\":27,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" let a = [[0u8; 1]; 4];\\\"}\"}",
"identifier": "{\"name\":\"complex\",\"span\":\"{\\\"line_start\\\":27,\\\"line_stop\\\":27,\\\"col_start\\\":7,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" let complex = 2u8;\\\"}\"}",
"span": {
"line_start": 27,
"line_stop": 27,
"col_start": 7,
"col_stop": 14,
"path": "",
"content": " let complex = 2u8;"
}
}
],
"type_": {
"IntegerType": "U8"
},
"value": {
"Value": {
"Integer": [
"U8",
"2",
{
"line_start": 27,
"line_stop": 27,
"col_start": 17,
"col_stop": 20,
"path": "",
"content": " let complex = 2u8;"
}
]
}
},
"span": {
"line_start": 27,
"line_stop": 27,
"col_start": 3,
"col_stop": 20,
"path": "",
"content": " let complex = 2u8;"
}
}
},
{
"Assign": {
"operation": "Assign",
"assignee": {
"identifier": "{\"name\":\"complex\",\"span\":\"{\\\"line_start\\\":28,\\\"line_stop\\\":28,\\\"col_start\\\":3,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" complex += 22u8 - 2u8+ 1u8;\\\"}\"}",
"accesses": [],
"span": {
"line_start": 28,
"line_stop": 28,
"col_start": 3,
"col_stop": 10,
"path": "",
"content": " complex += 22u8 - 2u8+ 1u8;"
}
},
"value": {
"Binary": {
"left": {
"Identifier": "{\"name\":\"complex\",\"span\":\"{\\\"line_start\\\":28,\\\"line_stop\\\":28,\\\"col_start\\\":3,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" complex += 22u8 - 2u8+ 1u8;\\\"}\"}"
},
"right": {
"Binary": {
"left": {
"Binary": {
"left": {
"Value": {
"Integer": [
"U8",
"22",
{
"line_start": 28,
"line_stop": 28,
"col_start": 14,
"col_stop": 18,
"path": "",
"content": " complex += 22u8 - 2u8+ 1u8;"
}
]
}
},
"right": {
"Value": {
"Integer": [
"U8",
"2",
{
"line_start": 28,
"line_stop": 28,
"col_start": 21,
"col_stop": 24,
"path": "",
"content": " complex += 22u8 - 2u8+ 1u8;"
}
]
}
},
"op": "Sub",
"span": {
"line_start": 28,
"line_stop": 28,
"col_start": 14,
"col_stop": 24,
"path": "",
"content": " complex += 22u8 - 2u8+ 1u8;"
}
}
},
"right": {
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 28,
"line_stop": 28,
"col_start": 26,
"col_stop": 29,
"path": "",
"content": " complex += 22u8 - 2u8+ 1u8;"
}
]
}
},
"op": "Add",
"span": {
"line_start": 28,
"line_stop": 28,
"col_start": 14,
"col_stop": 29,
"path": "",
"content": " complex += 22u8 - 2u8+ 1u8;"
}
}
},
"op": "Add",
"span": {
"line_start": 28,
"line_stop": 28,
"col_start": 3,
"col_stop": 29,
"path": "",
"content": " complex += 22u8 - 2u8+ 1u8;"
}
}
},
"span": {
"line_start": 28,
"line_stop": 28,
"col_start": 3,
"col_stop": 29,
"path": "",
"content": " complex += 22u8 - 2u8+ 1u8;"
}
}
},
{
"Console": {
"function": {
"Assert": {
"Binary": {
"left": {
"Identifier": "{\"name\":\"complex\",\"span\":\"{\\\"line_start\\\":29,\\\"line_stop\\\":29,\\\"col_start\\\":18,\\\"col_stop\\\":25,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" console.assert(complex == 23u8);\\\"}\"}"
},
"right": {
"Value": {
"Integer": [
"U8",
"23",
{
"line_start": 29,
"line_stop": 29,
"col_start": 29,
"col_stop": 33,
"path": "",
"content": " console.assert(complex == 23u8);"
}
]
}
},
"op": "Eq",
"span": {
"line_start": 29,
"line_stop": 29,
"col_start": 18,
"col_stop": 33,
"path": "",
"content": " console.assert(complex == 23u8);"
}
}
}
},
"span": {
"line_start": 29,
"line_stop": 29,
"col_start": 3,
"col_stop": 33,
"path": "",
"content": " console.assert(complex == 23u8);"
}
}
},
{
"Definition": {
"declaration_type": "Let",
"variable_names": [
{
"mutable": true,
"identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":30,\\\"line_stop\\\":30,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" let a = [[0u8; 1]; 4];\\\"}\"}",
"span": {
"line_start": 30,
"line_stop": 30,
"col_start": 7,
"col_stop": 8,
"path": "",
"content": " let a = [[0u8; 1]; 4];"
}
}
],
"type_": null,
"type_": {
"Array": [
{
"Array": [
{
"IntegerType": "U8"
},
[
{
"value": "1"
}
]
]
},
[
{
"value": "4"
}
]
]
},
"value": {
"ArrayInit": {
"element": {
@ -1102,8 +1357,8 @@
"U8",
"0",
{
"line_start": 27,
"line_stop": 27,
"line_start": 30,
"line_stop": 30,
"col_start": 13,
"col_stop": 16,
"path": "",
@ -1118,8 +1373,8 @@
}
],
"span": {
"line_start": 27,
"line_stop": 27,
"line_start": 30,
"line_stop": 30,
"col_start": 12,
"col_stop": 20,
"path": "",
@ -1133,8 +1388,8 @@
}
],
"span": {
"line_start": 27,
"line_stop": 27,
"line_start": 30,
"line_stop": 30,
"col_start": 11,
"col_stop": 24,
"path": "",
@ -1143,8 +1398,8 @@
}
},
"span": {
"line_start": 27,
"line_stop": 27,
"line_start": 30,
"line_stop": 30,
"col_start": 3,
"col_stop": 24,
"path": "",
@ -1156,16 +1411,17 @@
"Assign": {
"operation": "Assign",
"assignee": {
"identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":28,\\\"line_stop\\\":28,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" a[2][0] += 1u8;\\\"}\"}",
"identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":31,\\\"line_stop\\\":31,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" a[2][0] += 1u8;\\\"}\"}",
"accesses": [
{
"ArrayIndex": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"2",
{
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 5,
"col_stop": 6,
"path": "",
@ -1178,11 +1434,12 @@
{
"ArrayIndex": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 8,
"col_stop": 9,
"path": "",
@ -1194,8 +1451,8 @@
}
],
"span": {
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 3,
"col_stop": 10,
"path": "",
@ -1209,15 +1466,16 @@
"array": {
"ArrayAccess": {
"array": {
"Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":28,\\\"line_stop\\\":28,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" a[2][0] += 1u8;\\\"}\"}"
"Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":31,\\\"line_stop\\\":31,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" a[2][0] += 1u8;\\\"}\"}"
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"2",
{
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 5,
"col_stop": 6,
"path": "",
@ -1227,8 +1485,8 @@
}
},
"span": {
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 3,
"col_stop": 17,
"path": "",
@ -1238,11 +1496,12 @@
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 8,
"col_stop": 9,
"path": "",
@ -1252,8 +1511,8 @@
}
},
"span": {
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 3,
"col_stop": 17,
"path": "",
@ -1267,8 +1526,8 @@
"U8",
"1",
{
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 14,
"col_stop": 17,
"path": "",
@ -1279,8 +1538,8 @@
},
"op": "Add",
"span": {
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 3,
"col_stop": 17,
"path": "",
@ -1289,8 +1548,8 @@
}
},
"span": {
"line_start": 28,
"line_stop": 28,
"line_start": 31,
"line_stop": 31,
"col_start": 3,
"col_stop": 17,
"path": "",
@ -1308,15 +1567,16 @@
"array": {
"ArrayAccess": {
"array": {
"Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":29,\\\"line_stop\\\":29,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" console.assert(a[2][0] == 1u8);\\\"}\"}"
"Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":32,\\\"line_stop\\\":32,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" console.assert(a[2][0] == 1u8);\\\"}\"}"
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"2",
{
"line_start": 29,
"line_stop": 29,
"line_start": 32,
"line_stop": 32,
"col_start": 20,
"col_stop": 21,
"path": "",
@ -1326,8 +1586,8 @@
}
},
"span": {
"line_start": 29,
"line_stop": 29,
"line_start": 32,
"line_stop": 32,
"col_start": 18,
"col_stop": 22,
"path": "",
@ -1337,11 +1597,12 @@
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 29,
"line_stop": 29,
"line_start": 32,
"line_stop": 32,
"col_start": 23,
"col_stop": 24,
"path": "",
@ -1351,8 +1612,8 @@
}
},
"span": {
"line_start": 29,
"line_stop": 29,
"line_start": 32,
"line_stop": 32,
"col_start": 18,
"col_stop": 25,
"path": "",
@ -1366,8 +1627,8 @@
"U8",
"1",
{
"line_start": 29,
"line_stop": 29,
"line_start": 32,
"line_stop": 32,
"col_start": 29,
"col_stop": 32,
"path": "",
@ -1378,8 +1639,8 @@
},
"op": "Eq",
"span": {
"line_start": 29,
"line_stop": 29,
"line_start": 32,
"line_stop": 32,
"col_start": 18,
"col_stop": 32,
"path": "",
@ -1389,8 +1650,8 @@
}
},
"span": {
"line_start": 29,
"line_stop": 29,
"line_start": 32,
"line_stop": 32,
"col_start": 3,
"col_stop": 32,
"path": "",
@ -1404,10 +1665,10 @@
"variable_names": [
{
"mutable": true,
"identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":31,\\\"line_stop\\\":31,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" let b = [0u8; (4, 1)];\\\"}\"}",
"identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":34,\\\"line_stop\\\":34,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" let b = [0u8; (4, 1)];\\\"}\"}",
"span": {
"line_start": 31,
"line_stop": 31,
"line_start": 34,
"line_stop": 34,
"col_start": 7,
"col_stop": 8,
"path": "",
@ -1415,7 +1676,27 @@
}
}
],
"type_": null,
"type_": {
"Array": [
{
"Array": [
{
"IntegerType": "U8"
},
[
{
"value": "1"
}
]
]
},
[
{
"value": "4"
}
]
]
},
"value": {
"ArrayInit": {
"element": {
@ -1426,8 +1707,8 @@
"U8",
"0",
{
"line_start": 31,
"line_stop": 31,
"line_start": 34,
"line_stop": 34,
"col_start": 12,
"col_stop": 15,
"path": "",
@ -1442,8 +1723,8 @@
}
],
"span": {
"line_start": 31,
"line_stop": 31,
"line_start": 34,
"line_stop": 34,
"col_start": 11,
"col_stop": 24,
"path": "",
@ -1457,8 +1738,8 @@
}
],
"span": {
"line_start": 31,
"line_stop": 31,
"line_start": 34,
"line_stop": 34,
"col_start": 11,
"col_stop": 24,
"path": "",
@ -1467,8 +1748,8 @@
}
},
"span": {
"line_start": 31,
"line_stop": 31,
"line_start": 34,
"line_stop": 34,
"col_start": 3,
"col_stop": 24,
"path": "",
@ -1480,16 +1761,17 @@
"Assign": {
"operation": "Assign",
"assignee": {
"identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":32,\\\"line_stop\\\":32,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" b[2][0] += 1u8;\\\"}\"}",
"identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":35,\\\"line_stop\\\":35,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" b[2][0] += 1u8;\\\"}\"}",
"accesses": [
{
"ArrayIndex": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"2",
{
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 5,
"col_stop": 6,
"path": "",
@ -1502,11 +1784,12 @@
{
"ArrayIndex": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 8,
"col_stop": 9,
"path": "",
@ -1518,8 +1801,8 @@
}
],
"span": {
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 3,
"col_stop": 10,
"path": "",
@ -1533,15 +1816,16 @@
"array": {
"ArrayAccess": {
"array": {
"Identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":32,\\\"line_stop\\\":32,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" b[2][0] += 1u8;\\\"}\"}"
"Identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":35,\\\"line_stop\\\":35,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" b[2][0] += 1u8;\\\"}\"}"
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"2",
{
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 5,
"col_stop": 6,
"path": "",
@ -1551,8 +1835,8 @@
}
},
"span": {
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 3,
"col_stop": 17,
"path": "",
@ -1562,11 +1846,12 @@
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 8,
"col_stop": 9,
"path": "",
@ -1576,8 +1861,8 @@
}
},
"span": {
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 3,
"col_stop": 17,
"path": "",
@ -1591,8 +1876,8 @@
"U8",
"1",
{
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 14,
"col_stop": 17,
"path": "",
@ -1603,8 +1888,8 @@
},
"op": "Add",
"span": {
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 3,
"col_stop": 17,
"path": "",
@ -1613,8 +1898,8 @@
}
},
"span": {
"line_start": 32,
"line_stop": 32,
"line_start": 35,
"line_stop": 35,
"col_start": 3,
"col_stop": 17,
"path": "",
@ -1632,15 +1917,16 @@
"array": {
"ArrayAccess": {
"array": {
"Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":33,\\\"line_stop\\\":33,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" console.assert(a[2][0] == 1u8);\\\"}\"}"
"Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":36,\\\"line_stop\\\":36,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" console.assert(a[2][0] == 1u8);\\\"}\"}"
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"2",
{
"line_start": 33,
"line_stop": 33,
"line_start": 36,
"line_stop": 36,
"col_start": 20,
"col_stop": 21,
"path": "",
@ -1650,8 +1936,8 @@
}
},
"span": {
"line_start": 33,
"line_stop": 33,
"line_start": 36,
"line_stop": 36,
"col_start": 18,
"col_stop": 22,
"path": "",
@ -1661,11 +1947,12 @@
},
"index": {
"Value": {
"Implicit": [
"Integer": [
"U32",
"0",
{
"line_start": 33,
"line_stop": 33,
"line_start": 36,
"line_stop": 36,
"col_start": 23,
"col_stop": 24,
"path": "",
@ -1675,8 +1962,8 @@
}
},
"span": {
"line_start": 33,
"line_stop": 33,
"line_start": 36,
"line_stop": 36,
"col_start": 18,
"col_stop": 25,
"path": "",
@ -1690,8 +1977,8 @@
"U8",
"1",
{
"line_start": 33,
"line_stop": 33,
"line_start": 36,
"line_stop": 36,
"col_start": 29,
"col_stop": 32,
"path": "",
@ -1702,8 +1989,8 @@
},
"op": "Eq",
"span": {
"line_start": 33,
"line_stop": 33,
"line_start": 36,
"line_stop": 36,
"col_start": 18,
"col_stop": 32,
"path": "",
@ -1713,8 +2000,8 @@
}
},
"span": {
"line_start": 33,
"line_stop": 33,
"line_start": 36,
"line_stop": 36,
"col_start": 3,
"col_stop": 32,
"path": "",
@ -1725,7 +2012,7 @@
],
"span": {
"line_start": 10,
"line_stop": 34,
"line_stop": 37,
"col_start": 17,
"col_stop": 2,
"path": "",
@ -1734,11 +2021,11 @@
},
"span": {
"line_start": 10,
"line_stop": 34,
"line_stop": 37,
"col_start": 1,
"col_stop": 2,
"path": "",
"content": "function main() {\n...\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
"content": "function main() {\n...\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
}
}
}

3
compiler/tests/canonicalization/compound_assignment.leo
View File

@ -24,6 +24,9 @@ function main() {
foo.f += 2u8;
console.assert(foo.f == 8u8);
let complex = 2u8;
complex += 22u8 - 2u8+ 1u8;
console.assert(complex == 23u8);
let a = [[0u8; 1]; 4];
a[2][0] += 1u8;
console.assert(a[2][0] == 1u8);

4
compiler/tests/canonicalization/illegal_array_range_fail.leo Normal file
View File

@ -0,0 +1,4 @@
function main () {
let x = [1u32; 5];
x[..2] += 1;
}

8
compiler/tests/canonicalization/mod.rs
View File

@ -87,3 +87,11 @@ fn test_compound_assignment() {
assert_eq!(expected_ast, ast);
}
#[test]
fn test_illegal_array_range_fail() {
// Check program is invalid.
let program_string = include_str!("illegal_array_range_fail.leo");
let program = parse_program(program_string);
assert!(program.is_err());
}

1
compiler/tests/mod.rs
View File

@ -37,6 +37,7 @@ pub mod mutability;
pub mod statements;
pub mod syntax;
pub mod tuples;
pub mod type_inference;
use leo_asg::{new_alloc_context, new_context, AsgContext};
use leo_ast::{InputValue, MainInput};

962
compiler/tests/type_inference/basic.json Normal file
View File

@ -0,0 +1,962 @@
{
"name": "",
"expected_input": [],
"imports": [],
"circuits": {
"{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":12,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit Foo {}\\\"}\"}": {
"circuit_name": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":12,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit Foo {}\\\"}\"}",
"members": []
}
},
"functions": {
"{\"name\":\"two\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":10,\\\"col_stop\\\":13,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function two() -> u8 {\\\"}\"}": {
"annotations": [],
"identifier": "{\"name\":\"two\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":10,\\\"col_stop\\\":13,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function two() -> u8 {\\\"}\"}",
"input": [],
"output": {
"IntegerType": "U8"
},
"block": {
"statements": [
{
"Return": {
"expression": {
"Value": {
"Integer": [
"U8",
"2",
{
"line_start": 4,
"line_stop": 4,
"col_start": 10,
"col_stop": 13,
"path": "",
"content": " return 2u8"
}
]
}
},
"span": {
"line_start": 4,
"line_stop": 4,
"col_start": 3,
"col_stop": 13,
"path": "",
"content": " return 2u8"
}
}
}
],
"span": {
"line_start": 3,
"line_stop": 5,
"col_start": 22,
"col_stop": 2,
"path": "",
"content": "function two() -> u8 {\n...\n}"
}
},
"span": {
"line_start": 3,
"line_stop": 5,
"col_start": 1,
"col_stop": 2,
"path": "",
"content": "function two() -> u8 {\n...\n}"
}
},
"{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":7,\\\"line_stop\\\":7,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main() {\\\"}\"}": {
"annotations": [],
"identifier": "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":7,\\\"line_stop\\\":7,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main() {\\\"}\"}",
"input": [],
"output": {
"Tuple": []
},
"block": {
"statements": [
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":8,\\\"line_stop\\\":8,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const a = 1u8;\\\"}\"}",
"span": {
"line_start": 8,
"line_stop": 8,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const a = 1u8;"
}
}
],
"type_": {
"IntegerType": "U8"
},
"value": {
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 8,
"line_stop": 8,
"col_start": 13,
"col_stop": 16,
"path": "",
"content": " const a = 1u8;"
}
]
}
},
"span": {
"line_start": 8,
"line_stop": 8,
"col_start": 3,
"col_stop": 16,
"path": "",
"content": " const a = 1u8;"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const b = 1field;\\\"}\"}",
"span": {
"line_start": 9,
"line_stop": 9,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const b = 1field;"
}
}
],
"type_": "Field",
"value": {
"Value": {
"Field": [
"1",
{
"line_start": 9,
"line_stop": 9,
"col_start": 13,
"col_stop": 19,
"path": "",
"content": " const b = 1field;"
}
]
}
},
"span": {
"line_start": 9,
"line_stop": 9,
"col_start": 3,
"col_stop": 19,
"path": "",
"content": " const b = 1field;"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"c\",\"span\":\"{\\\"line_start\\\":10,\\\"line_stop\\\":10,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const c = 1group;\\\"}\"}",
"span": {
"line_start": 10,
"line_stop": 10,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const c = 1group;"
}
}
],
"type_": "Group",
"value": {
"Value": {
"Group": {
"Single": [
"1",
{
"line_start": 10,
"line_stop": 10,
"col_start": 13,
"col_stop": 19,
"path": "",
"content": " const c = 1group;"
}
]
}
}
},
"span": {
"line_start": 10,
"line_stop": 10,
"col_start": 3,
"col_stop": 19,
"path": "",
"content": " const c = 1group;"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"d\",\"span\":\"{\\\"line_start\\\":11,\\\"line_stop\\\":11,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const d = (0, 1)group;\\\"}\"}",
"span": {
"line_start": 11,
"line_stop": 11,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const d = (0, 1)group;"
}
}
],
"type_": "Group",
"value": {
"Value": {
"Group": {
"Tuple": {
"x": {
"Number": [
"0",
{
"line_start": 11,
"line_stop": 11,
"col_start": 14,
"col_stop": 15,
"path": "",
"content": " const d = (0, 1)group;"
}
]
},
"y": {
"Number": [
"1",
{
"line_start": 11,
"line_stop": 11,
"col_start": 17,
"col_stop": 18,
"path": "",
"content": " const d = (0, 1)group;"
}
]
},
"span": {
"line_start": 11,
"line_stop": 11,
"col_start": 14,
"col_stop": 24,
"path": "",
"content": " const d = (0, 1)group;"
}
}
}
}
},
"span": {
"line_start": 11,
"line_stop": 11,
"col_start": 3,
"col_stop": 24,
"path": "",
"content": " const d = (0, 1)group;"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"e\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const e = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);\\\"}\"}",
"span": {
"line_start": 12,
"line_stop": 12,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const e = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);"
}
}
],
"type_": "Address",
"value": {
"Value": {
"Address": [
"aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8",
{
"line_start": 12,
"line_stop": 12,
"col_start": 13,
"col_stop": 85,
"path": "",
"content": " const e = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);"
}
]
}
},
"span": {
"line_start": 12,
"line_stop": 12,
"col_start": 3,
"col_stop": 85,
"path": "",
"content": " const e = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"f\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const f = two();\\\"}\"}",
"span": {
"line_start": 13,
"line_stop": 13,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const f = two();"
}
}
],
"type_": {
"IntegerType": "U8"
},
"value": {
"Call": {
"function": {
"Identifier": "{\"name\":\"two\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":13,\\\"col_stop\\\":16,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const f = two();\\\"}\"}"
},
"arguments": [],
"span": {
"line_start": 13,
"line_stop": 13,
"col_start": 13,
"col_stop": 18,
"path": "",
"content": " const f = two();"
}
}
},
"span": {
"line_start": 13,
"line_stop": 13,
"col_start": 3,
"col_stop": 18,
"path": "",
"content": " const f = two();"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"g\",\"span\":\"{\\\"line_start\\\":14,\\\"line_stop\\\":14,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const g = [0u8; (3, 2)];\\\"}\"}",
"span": {
"line_start": 14,
"line_stop": 14,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const g = [0u8; (3, 2)];"
}
}
],
"type_": {
"Array": [
{
"Array": [
{
"IntegerType": "U8"
},
[
{
"value": "2"
}
]
]
},
[
{
"value": "3"
}
]
]
},
"value": {
"ArrayInit": {
"element": {
"ArrayInit": {
"element": {
"Value": {
"Integer": [
"U8",
"0",
{
"line_start": 14,
"line_stop": 14,
"col_start": 14,
"col_stop": 17,
"path": "",
"content": " const g = [0u8; (3, 2)];"
}
]
}
},
"dimensions": [
{
"value": "2"
}
],
"span": {
"line_start": 14,
"line_stop": 14,
"col_start": 13,
"col_stop": 26,
"path": "",
"content": " const g = [0u8; (3, 2)];"
}
}
},
"dimensions": [
{
"value": "3"
}
],
"span": {
"line_start": 14,
"line_stop": 14,
"col_start": 13,
"col_stop": 26,
"path": "",
"content": " const g = [0u8; (3, 2)];"
}
}
},
"span": {
"line_start": 14,
"line_stop": 14,
"col_start": 3,
"col_stop": 26,
"path": "",
"content": " const g = [0u8; (3, 2)];"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"h\",\"span\":\"{\\\"line_start\\\":15,\\\"line_stop\\\":15,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const h = [[0u8; 3]; 2];\\\"}\"}",
"span": {
"line_start": 15,
"line_stop": 15,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const h = [[0u8; 3]; 2];"
}
}
],
"type_": {
"Array": [
{
"Array": [
{
"IntegerType": "U8"
},
[
{
"value": "3"
}
]
]
},
[
{
"value": "2"
}
]
]
},
"value": {
"ArrayInit": {
"element": {
"ArrayInit": {
"element": {
"Value": {
"Integer": [
"U8",
"0",
{
"line_start": 15,
"line_stop": 15,
"col_start": 15,
"col_stop": 18,
"path": "",
"content": " const h = [[0u8; 3]; 2];"
}
]
}
},
"dimensions": [
{
"value": "3"
}
],
"span": {
"line_start": 15,
"line_stop": 15,
"col_start": 14,
"col_stop": 22,
"path": "",
"content": " const h = [[0u8; 3]; 2];"
}
}
},
"dimensions": [
{
"value": "2"
}
],
"span": {
"line_start": 15,
"line_stop": 15,
"col_start": 13,
"col_stop": 26,
"path": "",
"content": " const h = [[0u8; 3]; 2];"
}
}
},
"span": {
"line_start": 15,
"line_stop": 15,
"col_start": 3,
"col_stop": 26,
"path": "",
"content": " const h = [[0u8; 3]; 2];"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"i\",\"span\":\"{\\\"line_start\\\":16,\\\"line_stop\\\":16,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const i = [1u8, 1u8, 1u8];\\\"}\"}",
"span": {
"line_start": 16,
"line_stop": 16,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const i = [1u8, 1u8, 1u8];"
}
}
],
"type_": {
"Array": [
{
"IntegerType": "U8"
},
[
{
"value": "3"
}
]
]
},
"value": {
"ArrayInline": {
"elements": [
{
"Expression": {
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 16,
"line_stop": 16,
"col_start": 14,
"col_stop": 17,
"path": "",
"content": " const i = [1u8, 1u8, 1u8];"
}
]
}
}
},
{
"Expression": {
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 16,
"line_stop": 16,
"col_start": 19,
"col_stop": 22,
"path": "",
"content": " const i = [1u8, 1u8, 1u8];"
}
]
}
}
},
{
"Expression": {
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 16,
"line_stop": 16,
"col_start": 24,
"col_stop": 27,
"path": "",
"content": " const i = [1u8, 1u8, 1u8];"
}
]
}
}
}
],
"span": {
"line_start": 16,
"line_stop": 16,
"col_start": 13,
"col_stop": 28,
"path": "",
"content": " const i = [1u8, 1u8, 1u8];"
}
}
},
"span": {
"line_start": 16,
"line_stop": 16,
"col_start": 3,
"col_stop": 28,
"path": "",
"content": " const i = [1u8, 1u8, 1u8];"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"j\",\"span\":\"{\\\"line_start\\\":17,\\\"line_stop\\\":17,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const j = true;\\\"}\"}",
"span": {
"line_start": 17,
"line_stop": 17,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const j = true;"
}
}
],
"type_": "Boolean",
"value": {
"Value": {
"Boolean": [
"true",
{
"line_start": 17,
"line_stop": 17,
"col_start": 13,
"col_stop": 17,
"path": "",
"content": " const j = true;"
}
]
}
},
"span": {
"line_start": 17,
"line_stop": 17,
"col_start": 3,
"col_stop": 17,
"path": "",
"content": " const j = true;"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"k\",\"span\":\"{\\\"line_start\\\":18,\\\"line_stop\\\":18,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const k = (1u8, 1u8);\\\"}\"}",
"span": {
"line_start": 18,
"line_stop": 18,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const k = (1u8, 1u8);"
}
}
],
"type_": {
"Tuple": [
{
"IntegerType": "U8"
},
{
"IntegerType": "U8"
}
]
},
"value": {
"TupleInit": {
"elements": [
{
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 18,
"line_stop": 18,
"col_start": 14,
"col_stop": 17,
"path": "",
"content": " const k = (1u8, 1u8);"
}
]
}
},
{
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 18,
"line_stop": 18,
"col_start": 19,
"col_stop": 22,
"path": "",
"content": " const k = (1u8, 1u8);"
}
]
}
}
],
"span": {
"line_start": 18,
"line_stop": 18,
"col_start": 13,
"col_stop": 23,
"path": "",
"content": " const k = (1u8, 1u8);"
}
}
},
"span": {
"line_start": 18,
"line_stop": 18,
"col_start": 3,
"col_stop": 23,
"path": "",
"content": " const k = (1u8, 1u8);"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"l\",\"span\":\"{\\\"line_start\\\":19,\\\"line_stop\\\":19,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const l = (1u8, 1u8, true);\\\"}\"}",
"span": {
"line_start": 19,
"line_stop": 19,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const l = (1u8, 1u8, true);"
}
}
],
"type_": {
"Tuple": [
{
"IntegerType": "U8"
},
{
"IntegerType": "U8"
},
"Boolean"
]
},
"value": {
"TupleInit": {
"elements": [
{
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 19,
"line_stop": 19,
"col_start": 14,
"col_stop": 17,
"path": "",
"content": " const l = (1u8, 1u8, true);"
}
]
}
},
{
"Value": {
"Integer": [
"U8",
"1",
{
"line_start": 19,
"line_stop": 19,
"col_start": 19,
"col_stop": 22,
"path": "",
"content": " const l = (1u8, 1u8, true);"
}
]
}
},
{
"Value": {
"Boolean": [
"true",
{
"line_start": 19,
"line_stop": 19,
"col_start": 24,
"col_stop": 28,
"path": "",
"content": " const l = (1u8, 1u8, true);"
}
]
}
}
],
"span": {
"line_start": 19,
"line_stop": 19,
"col_start": 13,
"col_stop": 29,
"path": "",
"content": " const l = (1u8, 1u8, true);"
}
}
},
"span": {
"line_start": 19,
"line_stop": 19,
"col_start": 3,
"col_stop": 29,
"path": "",
"content": " const l = (1u8, 1u8, true);"
}
}
},
{
"Definition": {
"declaration_type": "Const",
"variable_names": [
{
"mutable": false,
"identifier": "{\"name\":\"m\",\"span\":\"{\\\"line_start\\\":20,\\\"line_stop\\\":20,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const m = Foo {};\\\"}\"}",
"span": {
"line_start": 20,
"line_stop": 20,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " const m = Foo {};"
}
}
],
"type_": {
"Circuit": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":12,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit Foo {}\\\"}\"}"
},
"value": {
"CircuitInit": {
"name": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":20,\\\"line_stop\\\":20,\\\"col_start\\\":13,\\\"col_stop\\\":16,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" const m = Foo {};\\\"}\"}",
"members": [],
"span": {
"line_start": 20,
"line_stop": 20,
"col_start": 13,
"col_stop": 19,
"path": "",
"content": " const m = Foo {};"
}
}
},
"span": {
"line_start": 20,
"line_stop": 20,
"col_start": 3,
"col_stop": 19,
"path": "",
"content": " const m = Foo {};"
}
}
}
],
"span": {
"line_start": 7,
"line_stop": 21,
"col_start": 17,
"col_stop": 2,
"path": "",
"content": "function main() {\n...\n}"
}
},
"span": {
"line_start": 7,
"line_stop": 21,
"col_start": 1,
"col_stop": 2,
"path": "",
"content": "function main() {\n...\n}\n\n\n\n\n\n\n\n\n\n\n\n"
}
}
}
}

21
compiler/tests/type_inference/basic.leo Normal file
View File

@ -0,0 +1,21 @@
circuit Foo {}
function two() -> u8 {
return 2u8;
}
function main() {
const a = 1u8;
const b = 1field;
const c = 1group;
const d = (0, 1)group;
const e = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
const f = two();
const g = [0u8; (3, 2)];
const h = [[0u8; 3]; 2];
const i = [1u8, 1u8, 1u8];
const j = true;
const k = (1u8, 1u8);
const l = (1u8, 1u8, true);
const m = Foo {};
}

242
compiler/tests/type_inference/for_loop_and_compound.json Normal file
View File

@ -0,0 +1,242 @@
{
"name": "",
"expected_input": [],
"imports": [],
"circuits": {},
"functions": {
"{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main() {\\\"}\"}": {
"annotations": [],
"identifier": "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main() {\\\"}\"}",
"input": [],
"output": {
"Tuple": []
},
"block": {
"statements": [
{
"Definition": {
"declaration_type": "Let",
"variable_names": [
{
"mutable": true,
"identifier": "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":2,\\\"line_stop\\\":2,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" let x = 10u16;\\\"}\"}",
"span": {
"line_start": 2,
"line_stop": 2,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " let x = 10u16;"
}
}
],
"type_": {
"IntegerType": "U16"
},
"value": {
"Value": {
"Integer": [
"U16",
"10",
{
"line_start": 2,
"line_stop": 2,
"col_start": 13,
"col_stop": 18,
"path": "",
"content": " let x = 10u16;"
}
]
}
},
"span": {
"line_start": 2,
"line_stop": 2,
"col_start": 5,
"col_stop": 18,
"path": "",
"content": " let x = 10u16;"
}
}
},
{
"Iteration": {
"variable": "{\"name\":\"i\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" for i in 0..3 {\\\"}\"}",
"start": {
"Value": {
"Integer": [
"U32",
"0",
{
"line_start": 3,
"line_stop": 3,
"col_start": 14,
"col_stop": 15,
"path": "",
"content": " for i in 0..3 {"
}
]
}
},
"stop": {
"Value": {
"Integer": [
"U32",
"3",
{
"line_start": 3,
"line_stop": 3,
"col_start": 17,
"col_stop": 18,
"path": "",
"content": " for i in 0..3 {"
}
]
}
},
"block": {
"statements": [
{
"Assign": {
"operation": "Assign",
"assignee": {
"identifier": "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" x -= 1;\\\"}\"}",
"accesses": [],
"span": {
"line_start": 4,
"line_stop": 4,
"col_start": 9,
"col_stop": 10,
"path": "",
"content": " x -= 1;"
}
},
"value": {
"Binary": {
"left": {
"Identifier": "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" x -= 1;\\\"}\"}"
},
"right": {
"Value": {
"Integer": [
"U16",
"1",
{
"line_start": 4,
"line_stop": 4,
"col_start": 14,
"col_stop": 15,
"path": "",
"content": " x -= 1;"
}
]
}
},
"op": "Sub",
"span": {
"line_start": 4,
"line_stop": 4,
"col_start": 9,
"col_stop": 15,
"path": "",
"content": " x -= 1;"
}
}
},
"span": {
"line_start": 4,
"line_stop": 4,
"col_start": 9,
"col_stop": 15,
"path": "",
"content": " x -= 1;"
}
}
}
],
"span": {
"line_start": 3,
"line_stop": 5,
"col_start": 19,
"col_stop": 6,
"path": "",
"content": " for i in 0..3 {\n...\n }"
}
},
"span": {
"line_start": 3,
"line_stop": 5,
"col_start": 5,
"col_stop": 6,
"path": "",
"content": " for i in 0..3 {\n...\n }"
}
}
},
{
"Console": {
"function": {
"Assert": {
"Binary": {
"left": {
"Identifier": "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":20,\\\"col_stop\\\":21,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\" console.assert(x == 7u16);\\\"}\"}"
},
"right": {
"Value": {
"Integer": [
"U16",
"7",
{
"line_start": 6,
"line_stop": 6,
"col_start": 25,
"col_stop": 29,
"path": "",
"content": " console.assert(x == 7u16);"
}
]
}
},
"op": "Eq",
"span": {
"line_start": 6,
"line_stop": 6,
"col_start": 20,
"col_stop": 29,
"path": "",
"content": " console.assert(x == 7u16);"
}
}
}
},
"span": {
"line_start": 6,
"line_stop": 6,
"col_start": 5,
"col_stop": 29,
"path": "",
"content": " console.assert(x == 7u16);"
}
}
}
],
"span": {
"line_start": 1,
"line_stop": 7,
"col_start": 17,
"col_stop": 2,
"path": "",
"content": "function main() {\n...\n}"
}
},
"span": {
"line_start": 1,
"line_stop": 7,
"col_start": 1,
"col_stop": 2,
"path": "",
"content": "function main() {\n...\n}\n\n\n\n"
}
}
}
}

5
tests/old/pass/statements/iteration_basic.leo → compiler/tests/type_inference/for_loop_and_compound.leo
View File

@ -1,8 +1,7 @@
function main() {
let x = 4u32;
let x = 10u16;
for i in 0..3 {
x -= 1;
}
console.assert(x == 1u32);
console.assert(x == 7u16);
}

85
compiler/tests/type_inference/mod.rs Normal file
View File

@ -0,0 +1,85 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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::{assert_satisfied, parse_program};
#[allow(unused)]
use leo_asg::{new_context, Asg, AsgContext};
use leo_ast::Ast;
use leo_compiler::TypeInferencePhase;
use leo_imports::ImportParser;
use leo_parser::parser;
thread_local! {
static THREAD_GLOBAL_CONTEXT: AsgContext<'static> = {
let leaked = Box::leak(Box::new(leo_asg::new_alloc_context()));
leo_asg::new_context(leaked)
}
}
pub fn thread_leaked_context() -> AsgContext<'static> {
THREAD_GLOBAL_CONTEXT.with(|f| *f)
}
pub fn parse_program_ast(file_string: &str) -> Ast {
const TEST_PROGRAM_PATH: &str = "";
let test_program_file_path = std::path::PathBuf::from(TEST_PROGRAM_PATH);
let mut ast = Ast::new(
parser::parse(test_program_file_path.to_str().expect("unwrap fail"), &file_string)
.expect("Failed to parse file."),
);
ast.canonicalize().expect("Failed to canonicalize program.");
let program = ast.clone().into_repr();
let asg = Asg::new(thread_leaked_context(), &program, &mut ImportParser::default())
.expect("Failed to create ASG from AST");
let new_ast = TypeInferencePhase::default()
.phase_ast(&program, &asg.into_repr())
.expect("Failed to produce type inference ast.");
new_ast
}
#[test]
fn test_basic() {
// Check program is valid.
let program_string = include_str!("basic.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
// Check we get expected ast.
let ast = parse_program_ast(program_string);
let expected_json = include_str!("basic.json");
let expected_ast: Ast = Ast::from_json_string(expected_json).expect("Unable to parse json.");
assert_eq!(expected_ast, ast);
}
#[test]
fn test_for_loop_and_compound() {
// Check program is valid.
let program_string = include_str!("for_loop_and_compound.leo");
let program = parse_program(program_string).unwrap();
assert_satisfied(program);
// Check we get expected ast.
let ast = parse_program_ast(program_string);
let expected_json = include_str!("for_loop_and_compound.json");
let expected_ast: Ast = Ast::from_json_string(expected_json).expect("Unable to parse json.");
assert_eq!(expected_ast, ast);
}

14
examples/silly-sudoku/inputs/test_input.in Normal file
View File

@ -0,0 +1,14 @@
// The program input for tmp-test/src/main.leo
[main]
puzzle: [u8; (3, 3)] = [[1, 0, 5],
[0, 2, 0],
[7, 0, 0]];
answer: [u8; (3, 3)] = [[1, 4, 5],
[3, 2, 6],
[7, 8, 9]];
expected: bool = true;
[registers]
r: bool = false;

302
grammar/README.md
View File

@ -57,59 +57,59 @@ without going beyond context-free grammars.
Instead of BNF's angle-bracket notation for nonterminals,
ABNF uses case-insensitive names consisting of letters, digits, and dashes,
e.g. HTTP-message and IPv6address.
e.g. `HTTP-message` and `IPv6address`.
ABNF includes an angle-bracket notation for prose descriptions,
e.g. <host, see [RFC3986], Section 3.2.2>,
e.g. `<host, see [RFC3986], Section 3.2.2>`,
usable as last resort in the definiens of a nonterminal.
While BNF allows arbitrary terminals,
ABNF uses only natural numbers as terminals,
and denotes them via:
(i) binary, decimal, or hexadecimal sequences,
e.g. %b1.11.1010, %d1.3.10, and %x.1.3.A
all denote the sequence of terminals '1 3 10';
e.g. `%b1.11.1010`, `%d1.3.10`, and `%x.1.3.A`
all denote the sequence of terminals [1, 3, 10];
(ii) binary, decimal, or hexadecimal ranges,
e.g. %x30-39 denotes any singleton sequence of terminals
'n' with 48 <= n <= 57 (an ASCII digit);
e.g. `%x30-39` denotes any singleton sequence of terminals
[_n_] with 48 <= _n_ <= 57 (an ASCII digit);
(iii) case-sensitive ASCII strings,
e.g. %s"Ab" denotes the sequence of terminals '65 98';
e.g. `%s"Ab"` denotes the sequence of terminals [65, 98];
and (iv) case-insensitive ASCII strings,
e.g. %i"ab", or just "ab", denotes
e.g. `%i"ab"`, or just `"ab"`, denotes
any sequence of terminals among
'65 66',
'65 98',
'97 66', and
'97 98'.
[65, 66],
[65, 98],
[97, 66], and
[97, 98].
ABNF terminals in suitable sets represent ASCII or Unicode characters.
ABNF allows repetition prefixes n*m,
where n and m are natural numbers in decimal notation;
ABNF allows repetition prefixes `n*m`,
where `n` and `m` are natural numbers in decimal notation;
if absent,
n defaults to 0, and
m defaults to infinity.
`n` defaults to 0, and
`m` defaults to infinity.
For example,
1*4HEXDIG denotes one to four HEXDIGs,
*3DIGIT denotes up to three DIGITs, and
1*OCTET denotes one or more OCTETs.
A single n prefix
abbreviates n*n,
e.g. 3DIGIT denotes three DIGITs.
`1*4HEXDIG` denotes one to four `HEXDIG`s,
`*3DIGIT` denotes up to three `DIGIT`s, and
`1*OCTET` denotes one or more `OCTET`s.
A single `n` prefix
abbreviates `n*n`,
e.g. `3DIGIT` denotes three `DIGIT`s.
Instead of BNF's |, ABNF uses / to separate alternatives.
Instead of BNF's `|`, ABNF uses `/` to separate alternatives.
Repetition prefixes have precedence over juxtapositions,
which have precedence over /.
which have precedence over `/`.
Round brackets group things and override the aforementioned precedence rules,
e.g. *(WSP / CRLF WSP) denotes sequences of terminals
e.g. `*(WSP / CRLF WSP)` denotes sequences of terminals
obtained by repeating, zero or more times,
either (i) a WSP or (ii) a CRLF followed by a WSP.
either (i) a `WSP` or (ii) a `CRLF` followed by a `WSP`.
Square brackets also group things but make them optional,
e.g. [":" port] is equivalent to 0*1(":" port).
e.g. `[":" port]` is equivalent to `0*1(":" port)`.
Instead of BNF's ::=, ABNF uses = to define nonterminals,
and =/ to incrementally add alternatives
Instead of BNF's `::=`, ABNF uses `=` to define nonterminals,
and `=/` to incrementally add alternatives
to previously defined nonterminals.
For example, the rule BIT = "0" / "1"
is equivalent to BIT = "0" followed by BIT =/ "1".
For example, the rule `BIT = "0" / "1"`
is equivalent to `BIT = "0"` followed by `BIT =/ "1"`.
The syntax of ABNF itself is formally specified in ABNF
(in Section 4 of the aforementioned RFC 5234,
@ -131,7 +131,7 @@ Structure
This ABNF grammar consists of two (sub-)grammars:
(i) a lexical grammar that describes how
sequence of characters are parsed into tokens, and
(ii) a syntactic grammar that described how
(ii) a syntactic grammar that describes how
tokens are parsed into expressions, statements, etc.
The adjectives 'lexical' and 'syntactic' are
the same ones used in the Java language reference,
@ -198,8 +198,8 @@ additive-expression =
These rules tell us
that the additive operators '+' and '-' have lower precedence
than the multiplicative operators '*' and '/',
that the additive operators `+` and `-` have lower precedence
than the multiplicative operators `*` and `/`,
and that both the additive and multiplicative operators associate to the left.
This may be best understood via the examples given below.
@ -295,7 +295,7 @@ Naming Convention
This ABNF grammar uses nonterminal names
that consist of complete English words, separated by dashes,
and that describe the construct the way it is in English.
For instance, we use the name 'conditional-statement'
For instance, we use the name `conditional-statement`
to describe conditional statements.
At the same time, this grammar establishes
@ -354,8 +354,8 @@ Lexical Grammar
A Leo file is a finite sequence of Unicode characters,
represented as Unicode code points,
which are numbers in the range form 0 to 10FFFFh.
These are captured by the ABNF rule 'character' below.
which are numbers in the range from 0 to 10FFFFh.
These are captured by the ABNF rule `character` below.
The lexical grammar defines how, at least conceptually,
the sequence of characters is turned into
@ -363,20 +363,20 @@ a sequence of tokens, comments, and whitespaces:
these entities are all defined by the grammar rules below.
As stated, the lexical grammar alone is ambiguous.
For example, the sequence of characters '**' (i.e. two stars)
could be equally parsed as two '*' symbol tokens or one '**' symbol token
(see rule for 'symbol' below).
As another example, the sequence or characters '<CR><LF>'
For example, the sequence of characters `**` (i.e. two stars)
could be equally parsed as two `*` symbol tokens or one `**` symbol token
(see rule for `symbol` below).
As another example, the sequence or characters `<CR><LF>`
(i.e. carriage return followed by line feed)
could be equally parsed as two line terminators or one
(see rule for 'newline').
(see rule for `newline`).
Thus, as often done in language syntax definitions,
the lexical grammar is disambiguated by
the extra-grammatical requirement that
the longest possible sequence of characters is always parsed.
This way, '**' must be parsed as one '**' symbol token,
and '<CR><LF>' must be parsed as one line terminator.
This way, `**` must be parsed as one `**` symbol token,
and `<CR><LF>` must be parsed as one line terminator.
As mentioned above, a character is any Unicode code point.
This grammar does not say how those are encoded in files (e.g. UTF-8):
@ -393,27 +393,27 @@ We give names to certain ASCII characters.
<a name="horizontal-tab"></a>
```abnf
horizontal-tab = %x9
horizontal-tab = %x9 ; <HT>
```
<a name="line-feed"></a>
```abnf
line-feed = %xA
line-feed = %xA ; <LF>
```
<a name="carriage-return"></a>
```abnf
carriage-return = %xD
carriage-return = %xD ; <CR>
```
<a name="space"></a>
```abnf
space = %x20
space = %x20 ; <SP>
```
<a name="double-quote"></a>
```abnf
double-quote = %x22
double-quote = %x22 ; "
```
We give names to complements of certain ASCII characters.
@ -432,12 +432,25 @@ not-star = %x0-29 / %x2B-10FFFF ; anything but *
<a name="not-line-feed-or-carriage-return"></a>
```abnf
not-line-feed-or-carriage-return = %x0-9 / %xB-C / %xE-10FFFF
; anything but LF or CR
; anything but <LF> or <CR>
```
<a name="not-double-quote-or-open-brace"></a>
```abnf
not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
; anything but " or {
```
<a name="not-double-quote-or-close-brace"></a>
```abnf
not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
; anything but " or }
```
<a name="not-star-or-slash"></a>
```abnf
not-star-or-slash = %x0-29 / %x2B-2E / %x30-10FFFF ; anything but * or /
not-star-or-slash = %x0-29 / %x2B-2E / %x30-10FFFF
; anything but * or /
```
Lines in Leo may be terminated via
@ -453,7 +466,7 @@ described above.
newline = line-feed / carriage-return / carriage-return line-feed
```
Go to: _[carriage-return](#user-content-carriage-return), [line-feed](#user-content-line-feed)_;
Go to: _[line-feed](#user-content-line-feed), [carriage-return](#user-content-carriage-return)_;
Line terminators form whitespace, along with spaces and horizontal tabs.
@ -463,16 +476,16 @@ Line terminators form whitespace, along with spaces and horizontal tabs.
whitespace = space / horizontal-tab / newline
```
Go to: _[space](#user-content-space), [horizontal-tab](#user-content-horizontal-tab), [newline](#user-content-newline)_;
Go to: _[horizontal-tab](#user-content-horizontal-tab), [space](#user-content-space), [newline](#user-content-newline)_;
There are two kinds of comments in Leo, as in other languages.
One is block comments of the form '/* ... */',
and the other is end-of-line comments of the form '// ...'.
The first kind start at '/*' and end at the first '*/',
One is block comments of the form `/* ... */`,
and the other is end-of-line comments of the form `// ...`.
The first kind start at `/*` and end at the first `*/`,
possibly spanning multiple (partial) lines;
these do no nest.
The second kind start at '//' and extend till the end of the line.
The second kind start at `//` and extend till the end of the line.
The rules about comments given below are similar to
the ones used in the Java language reference.
@ -481,7 +494,7 @@ the ones used in the Java language reference.
comment = block-comment / end-of-line-comment
```
Go to: _[block-comment](#user-content-block-comment), [end-of-line-comment](#user-content-end-of-line-comment)_;
Go to: _[end-of-line-comment](#user-content-end-of-line-comment), [block-comment](#user-content-block-comment)_;
<a name="block-comment"></a>
@ -498,7 +511,7 @@ rest-of-block-comment = "*" rest-of-block-comment-after-star
/ not-star rest-of-block-comment
```
Go to: _[rest-of-block-comment-after-star](#user-content-rest-of-block-comment-after-star), [not-star](#user-content-not-star), [rest-of-block-comment](#user-content-rest-of-block-comment)_;
Go to: _[not-star](#user-content-not-star), [rest-of-block-comment-after-star](#user-content-rest-of-block-comment-after-star), [rest-of-block-comment](#user-content-rest-of-block-comment)_;
<a name="rest-of-block-comment-after-star"></a>
@ -609,31 +622,16 @@ package-name = 1*( lowercase-letter / digit )
A format string is a sequence of characters, other than double quote,
surrounded by double quotes.
Within a format string, sub-strings '{}' are distinguished as containers
Within a format string, sub-strings `{}` are distinguished as containers
(these are the ones that may be matched with values
whose textual representation replaces the containers
in the printed string).
There is an implicit extra-grammatical requirements that
the explicit 'format-string-container' instances include
all the occurrences of '{}' in the parsed character sequence:
that is, there may not be two contiguous 'not-double-quote' instances
that are '{' and '}'.
<a name="format-string-container"></a>
```abnf
format-string-container = "{}"
```
<a name="not-double-quote-or-open-brace"></a>
```abnf
not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
```
<a name="not-double-quote-or-close-brace"></a>
```abnf
not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
```
<a name="format-string-element"></a>
```abnf
format-string-element = not-double-quote-or-open-brace
@ -641,7 +639,7 @@ format-string-element = not-double-quote-or-open-brace
/ format-string-container
```
Go to: _[not-double-quote-or-open-brace](#user-content-not-double-quote-or-open-brace), [not-double-quote-or-close-brace](#user-content-not-double-quote-or-close-brace), [format-string-container](#user-content-format-string-container)_;
Go to: _[not-double-quote-or-close-brace](#user-content-not-double-quote-or-close-brace), [format-string-container](#user-content-format-string-container), [not-double-quote-or-open-brace](#user-content-not-double-quote-or-open-brace)_;
<a name="format-string"></a>
@ -652,43 +650,7 @@ format-string = double-quote *format-string-element double-quote
Go to: _[double-quote](#user-content-double-quote)_;
Here is (part of this ABNF comment),
an alternative way to specify format strings,
which captures the extra-grammatical requirement above in the grammar,
but is more complicated:
```
not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
```
```
not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
```
```
format-string-element = not-double-quote-or-open-brace
/ "{" not-double-quote-or-close-brace
/ format-string-container
```
```
format-string = double-quote *format-string-element double-quote
```
It is not immediately clear which approach is better; there are tradeoffs.
We may choose to adopt this one in future revisions of the grammar.
Annotations have names, which are identifiers immediately preceded by '@'.
Annotations have names, which are identifiers immediately preceded by `@`.
<a name="annotation-name"></a>
```abnf
@ -699,7 +661,7 @@ Go to: _[identifier](#user-content-identifier)_;
A natural (number) is a sequence of one or more digits.
We allow leading zeros, e.g. '007'.
We allow leading zeros, e.g. `007`.
<a name="natural"></a>
```abnf
@ -707,7 +669,7 @@ natural = 1*digit
```
An integer (number) is either a natural or its negation.
We allow leading zeros also in negative numbers, e.g. '-007'.
We allow leading zeros also in negative numbers, e.g. `-007`.
<a name="integer"></a>
```abnf
@ -778,7 +740,7 @@ Boolean literals are the usual two.
boolean-literal = %s"true" / %s"false"
```
An address literal starts with 'aleo1'
An address literal starts with `aleo1`
and continues with exactly 58 lowercase letters and digits.
Thus an address always consists of 63 characters.
@ -802,16 +764,16 @@ atomic-literal = untyped-literal
/ address-literal
```
Go to: _[unsigned-literal](#user-content-unsigned-literal), [field-literal](#user-content-field-literal), [product-group-literal](#user-content-product-group-literal), [address-literal](#user-content-address-literal), [signed-literal](#user-content-signed-literal), [untyped-literal](#user-content-untyped-literal), [boolean-literal](#user-content-boolean-literal)_;
Go to: _[signed-literal](#user-content-signed-literal), [field-literal](#user-content-field-literal), [product-group-literal](#user-content-product-group-literal), [unsigned-literal](#user-content-unsigned-literal), [untyped-literal](#user-content-untyped-literal), [boolean-literal](#user-content-boolean-literal), [address-literal](#user-content-address-literal)_;
After defining the (mostly) alphanumeric tokens above,
it remains to define tokens for non-alphanumeric symbols such as "+" and "(".
it remains to define tokens for non-alphanumeric symbols such as `+` and `(`.
Different programming languages used different terminologies for these,
e.g. operators, separators, punctuators, etc.
Here we use 'symbol', for all of them.
Here we use `symbol`, for all of them.
We also include a token consisting of
a closing parenthesis immediately followed by 'group':
a closing parenthesis `)` immediately followed by `group`:
as defined in the syntactic grammar,
this is the final part of an affine group literal;
even though it includes letters,
@ -829,7 +791,7 @@ equality-operator = "=="
and defining 'symbol' in terms of those
and defining `symbol` in terms of those
@ -844,7 +806,7 @@ but it would help establish a terminology in the grammar,
namely the exact names of some of these token.
On the other hand, at least some of them are perhaps simple enough
that they could be just described in terms of their symbols,
e.g. 'double dot', 'question mark', etc.
e.g. double dot, question mark, etc.
<a name="symbol"></a>
```abnf
@ -875,7 +837,7 @@ token = keyword
/ symbol
```
Go to: _[format-string](#user-content-format-string), [annotation-name](#user-content-annotation-name), [symbol](#user-content-symbol), [keyword](#user-content-keyword), [atomic-literal](#user-content-atomic-literal), [identifier](#user-content-identifier), [package-name](#user-content-package-name)_;
Go to: _[package-name](#user-content-package-name), [format-string](#user-content-format-string), [symbol](#user-content-symbol), [identifier](#user-content-identifier), [atomic-literal](#user-content-atomic-literal), [annotation-name](#user-content-annotation-name), [keyword](#user-content-keyword)_;
@ -953,10 +915,10 @@ address-type = %s"address"
scalar-type = boolean-type / arithmetic-type / address-type
```
Go to: _[arithmetic-type](#user-content-arithmetic-type), [address-type](#user-content-address-type), [boolean-type](#user-content-boolean-type)_;
Go to: _[address-type](#user-content-address-type), [arithmetic-type](#user-content-arithmetic-type), [boolean-type](#user-content-boolean-type)_;
Circuit types are denoted by identifiers and the keyword 'Self'.
Circuit types are denoted by identifiers and the keyword `Self`.
The latter is only allowed inside a circuit definition,
to denote the circuit being defined.
@ -970,7 +932,7 @@ self-type = %s"Self"
circuit-type = identifier / self-type
```
Go to: _[identifier](#user-content-identifier), [self-type](#user-content-self-type)_;
Go to: _[self-type](#user-content-self-type), [identifier](#user-content-identifier)_;
A tuple type consists of zero, two, or more component types.
@ -993,7 +955,7 @@ or a tuple of one or more dimensions.
array-type = "[" type ";" array-dimensions "]"
```
Go to: _[type](#user-content-type), [array-dimensions](#user-content-array-dimensions)_;
Go to: _[array-dimensions](#user-content-array-dimensions), [type](#user-content-type)_;
<a name="array-dimensions"></a>
@ -1024,7 +986,7 @@ Scalar and aggregate types form all the types.
type = scalar-type / aggregate-type
```
Go to: _[scalar-type](#user-content-scalar-type), [aggregate-type](#user-content-aggregate-type)_;
Go to: _[aggregate-type](#user-content-aggregate-type), [scalar-type](#user-content-scalar-type)_;
The lexical grammar given earlier defines product group literals.
@ -1060,11 +1022,11 @@ A literal is either an atomic one or an affine group literal.
literal = atomic-literal / affine-group-literal
```
Go to: _[affine-group-literal](#user-content-affine-group-literal), [atomic-literal](#user-content-atomic-literal)_;
Go to: _[atomic-literal](#user-content-atomic-literal), [affine-group-literal](#user-content-affine-group-literal)_;
The following rule is not directly referenced in the rules for expressions
(which reference 'literal' instead),
(which reference `literal` instead),
but it is useful to establish terminology:
a group literal is either a product group literal or an affine group literal.
@ -1102,7 +1064,7 @@ primary-expression = identifier
/ circuit-expression
```
Go to: _[literal](#user-content-literal), [array-expression](#user-content-array-expression), [tuple-expression](#user-content-tuple-expression), [identifier](#user-content-identifier), [expression](#user-content-expression), [circuit-expression](#user-content-circuit-expression)_;
Go to: _[array-expression](#user-content-array-expression), [identifier](#user-content-identifier), [expression](#user-content-expression), [literal](#user-content-literal), [tuple-expression](#user-content-tuple-expression), [circuit-expression](#user-content-circuit-expression)_;
Tuple expressions construct tuples.
@ -1127,7 +1089,7 @@ Go to: _[tuple-construction](#user-content-tuple-construction)_;
Array expressions construct arrays.
There are two kinds:
one lists the element expressions (at least one),
including spreads (via '...') which are arrays being spliced in;
including spreads (via `...`) which are arrays being spliced in;
the other repeats (the value of) a single expression
across one or more dimensions.
@ -1155,7 +1117,7 @@ Go to: _[expression](#user-content-expression)_;
array-repeat-construction = "[" expression ";" array-dimensions "]"
```
Go to: _[array-dimensions](#user-content-array-dimensions), [expression](#user-content-expression)_;
Go to: _[expression](#user-content-expression), [array-dimensions](#user-content-array-dimensions)_;
<a name="array-construction"></a>
@ -1163,7 +1125,7 @@ Go to: _[array-dimensions](#user-content-array-dimensions), [expression](#user-c
array-construction = array-inline-construction / array-repeat-construction
```
Go to: _[array-inline-construction](#user-content-array-inline-construction), [array-repeat-construction](#user-content-array-repeat-construction)_;
Go to: _[array-repeat-construction](#user-content-array-repeat-construction), [array-inline-construction](#user-content-array-inline-construction)_;
<a name="array-expression"></a>
@ -1186,7 +1148,8 @@ so they are syntactically identical but semantically different.
<a name="circuit-construction"></a>
```abnf
circuit-construction = circuit-type "{"
circuit-inline-element *( "," circuit-inline-element ) [ "," ]
circuit-inline-element
*( "," circuit-inline-element ) [ "," ]
"}"
```
@ -1249,7 +1212,7 @@ postfix-expression = primary-expression
/ postfix-expression "[" [expression] ".." [expression] "]"
```
Go to: _[primary-expression](#user-content-primary-expression), [expression](#user-content-expression), [postfix-expression](#user-content-postfix-expression), [natural](#user-content-natural), [identifier](#user-content-identifier), [function-arguments](#user-content-function-arguments), [circuit-type](#user-content-circuit-type)_;
Go to: _[identifier](#user-content-identifier), [function-arguments](#user-content-function-arguments), [natural](#user-content-natural), [circuit-type](#user-content-circuit-type), [primary-expression](#user-content-primary-expression), [postfix-expression](#user-content-postfix-expression), [expression](#user-content-expression)_;
Unary operators have the highest operator precedence.
@ -1263,13 +1226,13 @@ unary-expression = postfix-expression
/ "-" unary-expression
```
Go to: _[unary-expression](#user-content-unary-expression), [postfix-expression](#user-content-postfix-expression)_;
Go to: _[postfix-expression](#user-content-postfix-expression), [unary-expression](#user-content-unary-expression)_;
Next in the operator precedence is exponentiation,
following mathematical practice.
The current rule below makes exponentiation left-associative,
i.e. 'a ** b ** c' must be parsed as '(a ** b) ** c'.
The current rule below makes exponentiation right-associative,
i.e. `a ** b ** c` must be parsed as `a ** (b ** c)`.
<a name="exponential-expression"></a>
```abnf
@ -1277,7 +1240,7 @@ exponential-expression = unary-expression
/ unary-expression "**" exponential-expression
```
Go to: _[exponential-expression](#user-content-exponential-expression), [unary-expression](#user-content-unary-expression)_;
Go to: _[unary-expression](#user-content-unary-expression), [exponential-expression](#user-content-exponential-expression)_;
Next in precedence come multiplication and division, both left-associative.
@ -1301,7 +1264,7 @@ additive-expression = multiplicative-expression
/ additive-expression "-" multiplicative-expression
```
Go to: _[multiplicative-expression](#user-content-multiplicative-expression), [additive-expression](#user-content-additive-expression)_;
Go to: _[additive-expression](#user-content-additive-expression), [multiplicative-expression](#user-content-multiplicative-expression)_;
Next in the precedence order are ordering relations.
@ -1351,7 +1314,7 @@ disjunctive-expression = conjunctive-expression
/ disjunctive-expression "||" conjunctive-expression
```
Go to: _[disjunctive-expression](#user-content-disjunctive-expression), [conjunctive-expression](#user-content-conjunctive-expression)_;
Go to: _[conjunctive-expression](#user-content-conjunctive-expression), [disjunctive-expression](#user-content-disjunctive-expression)_;
Finally we have conditional expressions.
@ -1396,7 +1359,7 @@ statement = expression-statement
/ block
```
Go to: _[assignment-statement](#user-content-assignment-statement), [block](#user-content-block), [variable-definition-statement](#user-content-variable-definition-statement), [return-statement](#user-content-return-statement), [loop-statement](#user-content-loop-statement), [console-statement](#user-content-console-statement), [conditional-statement](#user-content-conditional-statement), [expression-statement](#user-content-expression-statement)_;
Go to: _[return-statement](#user-content-return-statement), [loop-statement](#user-content-loop-statement), [assignment-statement](#user-content-assignment-statement), [expression-statement](#user-content-expression-statement), [console-statement](#user-content-console-statement), [block](#user-content-block), [conditional-statement](#user-content-conditional-statement), [variable-definition-statement](#user-content-variable-definition-statement)_;
<a name="block"></a>
@ -1415,8 +1378,7 @@ expression-statement = expression ";"
Go to: _[expression](#user-content-expression)_;
A return statement always takes an expression,
and does not end with a semicolon.
A return statement always takes an expression, and ends with a semicolon.
<a name="return-statement"></a>
```abnf
@ -1439,7 +1401,7 @@ variable-definition-statement = ( %s"let" / %s"const" )
[ ":" type ] "=" expression ";"
```
Go to: _[identifier-or-identifiers](#user-content-identifier-or-identifiers), [expression](#user-content-expression), [type](#user-content-type)_;
Go to: _[type](#user-content-type), [identifier-or-identifiers](#user-content-identifier-or-identifiers), [expression](#user-content-expression)_;
<a name="identifier-or-identifiers"></a>
@ -1472,7 +1434,7 @@ conditional-statement = branch
/ branch %s"else" conditional-statement
```
Go to: _[branch](#user-content-branch), [conditional-statement](#user-content-conditional-statement), [block](#user-content-block)_;
Go to: _[block](#user-content-block), [conditional-statement](#user-content-conditional-statement), [branch](#user-content-branch)_;
A loop statement implicitly defines a loop variable
@ -1484,11 +1446,11 @@ The body is a block.
loop-statement = %s"for" identifier %s"in" expression ".." expression block
```
Go to: _[block](#user-content-block), [identifier](#user-content-identifier), [expression](#user-content-expression)_;
Go to: _[block](#user-content-block), [expression](#user-content-expression), [identifier](#user-content-identifier)_;
An assignment statement is straightforward.
Based on the operator, the assignment may be simple (i.e. '=')
Based on the operator, the assignment may be simple (i.e. `=`)
or compound (i.e. combining assignment with an arithmetic operation).
<a name="assignment-operator"></a>
@ -1504,13 +1466,13 @@ assignment-statement = expression assignment-operator expression ";"
Go to: _[expression](#user-content-expression), [assignment-operator](#user-content-assignment-operator)_;
Console statements start with the 'console' keyword,
Console statements start with the `console` keyword,
followed by a console function call.
The call may be an assertion or a print command.
The former takes an expression (which must be boolean) as argument.
The latter takes either no argument,
or a format string followed by expressions,
whose number must match the number of containers '{}' in the format string.
whose number must match the number of containers `{}` in the format string.
Note that the console function names are identifiers, not keywords.
There are three kinds of print commands.
@ -1557,10 +1519,10 @@ Go to: _[format-string](#user-content-format-string)_;
print-call = print-function print-arguments
```
Go to: _[print-function](#user-content-print-function), [print-arguments](#user-content-print-arguments)_;
Go to: _[print-arguments](#user-content-print-arguments), [print-function](#user-content-print-function)_;
An annotation consists of an annotation name (which starts with '@')
An annotation consists of an annotation name (which starts with `@`)
with optional annotation arguments, which are identifiers.
Note that no parentheses are used if there are no arguments.
@ -1578,8 +1540,7 @@ The output type is optional, defaulting to the empty tuple type.
In general, a function input consists of an identifier and a type,
with an optional 'const' modifier.
Additionally, functions inside circuits
may start with a 'mut self' or 'const self' or 'self' parameter.
Furthermore, any function may end with an 'input' parameter.
may start with a `mut self` or `const self` or `self` parameter.
<a name="function-declaration"></a>
```abnf
@ -1588,7 +1549,7 @@ function-declaration = *annotation %s"function" identifier
block
```
Go to: _[block](#user-content-block), [function-parameters](#user-content-function-parameters), [identifier](#user-content-identifier), [type](#user-content-type)_;
Go to: _[type](#user-content-type), [block](#user-content-block), [identifier](#user-content-identifier), [function-parameters](#user-content-function-parameters)_;
<a name="function-parameters"></a>
@ -1598,7 +1559,7 @@ function-parameters = self-parameter
/ function-inputs
```
Go to: _[self-parameter](#user-content-self-parameter), [function-inputs](#user-content-function-inputs)_;
Go to: _[function-inputs](#user-content-function-inputs), [self-parameter](#user-content-self-parameter)_;
<a name="self-parameter"></a>
@ -1622,11 +1583,6 @@ function-input = [ %s"const" ] identifier ":" type
Go to: _[identifier](#user-content-identifier), [type](#user-content-type)_;
<a name="input-parameter"></a>
```abnf
input-parameter = %s"input"
```
A circuit member variable declaration consists of an identifier and a type.
A circuit member function declaration consists of a function declaration.
@ -1636,7 +1592,7 @@ member-declaration = member-variable-declaration
/ member-function-declaration
```
Go to: _[member-function-declaration](#user-content-member-function-declaration), [member-variable-declaration](#user-content-member-variable-declaration)_;
Go to: _[member-variable-declaration](#user-content-member-variable-declaration), [member-function-declaration](#user-content-member-function-declaration)_;
<a name="member-variable-declaration"></a>
@ -1644,7 +1600,7 @@ Go to: _[member-function-declaration](#user-content-member-function-declaration)
member-variable-declaration = identifier ":" type
```
Go to: _[type](#user-content-type), [identifier](#user-content-identifier)_;
Go to: _[identifier](#user-content-identifier), [type](#user-content-type)_;
<a name="member-function-declaration"></a>
@ -1667,7 +1623,7 @@ circuit-declaration = *annotation %s"circuit" identifier
Go to: _[identifier](#user-content-identifier), [member-declaration](#user-content-member-declaration)_;
An import declaration consists of the 'import' keyword
An import declaration consists of the `import` keyword
followed by a package path, which may be one of the following:
a single wildcard;
an identifier, optionally followed by a local renamer;
@ -1693,7 +1649,7 @@ package-path = "*"
/ "(" package-path *( "," package-path ) [","] ")"
```
Go to: _[package-path](#user-content-package-path), [package-name](#user-content-package-name), [identifier](#user-content-identifier)_;
Go to: _[package-name](#user-content-package-name), [package-path](#user-content-package-path), [identifier](#user-content-identifier)_;
Finally, we define a file as a sequence of zero or more declarations.
@ -1705,7 +1661,7 @@ declaration = import-declaration
/ circuit-declaration
```
Go to: _[import-declaration](#user-content-import-declaration), [function-declaration](#user-content-function-declaration), [circuit-declaration](#user-content-circuit-declaration)_;
Go to: _[function-declaration](#user-content-function-declaration), [circuit-declaration](#user-content-circuit-declaration), [import-declaration](#user-content-import-declaration)_;
<a name="file"></a>
@ -1720,16 +1676,18 @@ file = *declaration
Format Note
-----------
The ABNF standard requires grammars to consist of lines terminated by CR LF
The ABNF standard requires grammars
to consist of lines terminated by `<CR><LF>`
(i.e. carriage return followed by line feed, DOS/Windows-style),
as explained in the background on ABNF earlier in this file.
This file's lines are therefore terminated by CR LF.
This file's lines are therefore terminated by `<CR><LF>`.
To avoid losing this requirement across systems,
this file is marked as 'text eol=crlf' in .gitattributes:
this file is marked as `text eol=crlf` in `.gitattributes`:
this means that the file is textual, enabling visual diffs,
but its lines will always be terminated by CR LF on any system.
but its lines will always be terminated by `<CR><LF>` on any system.
Note that this CR LF requirement only applies to the grammar files themselves.
Note that this `<CR><LF>` requirement only applies
to the grammar files themselves.
It does not apply to the lines of the languages described by the grammar.
ABNF grammars may describe any kind of languages,
with any kind of line terminators,

207
grammar/abnf-grammar.txt
View File

@ -53,59 +53,59 @@
; Instead of BNF's angle-bracket notation for nonterminals,
; ABNF uses case-insensitive names consisting of letters, digits, and dashes,
; e.g. HTTP-message and IPv6address.
; e.g. `HTTP-message` and `IPv6address`.
; ABNF includes an angle-bracket notation for prose descriptions,
; e.g. <host, see [RFC3986], Section 3.2.2>,
; e.g. `<host, see [RFC3986], Section 3.2.2>`,
; usable as last resort in the definiens of a nonterminal.
; While BNF allows arbitrary terminals,
; ABNF uses only natural numbers as terminals,
; and denotes them via:
; (i) binary, decimal, or hexadecimal sequences,
; e.g. %b1.11.1010, %d1.3.10, and %x.1.3.A
; all denote the sequence of terminals '1 3 10';
; e.g. `%b1.11.1010`, `%d1.3.10`, and `%x.1.3.A`
; all denote the sequence of terminals [1, 3, 10];
; (ii) binary, decimal, or hexadecimal ranges,
; e.g. %x30-39 denotes any singleton sequence of terminals
; 'n' with 48 <= n <= 57 (an ASCII digit);
; e.g. `%x30-39` denotes any singleton sequence of terminals
; [_n_] with 48 <= _n_ <= 57 (an ASCII digit);
; (iii) case-sensitive ASCII strings,
; e.g. %s"Ab" denotes the sequence of terminals '65 98';
; e.g. `%s"Ab"` denotes the sequence of terminals [65, 98];
; and (iv) case-insensitive ASCII strings,
; e.g. %i"ab", or just "ab", denotes
; e.g. `%i"ab"`, or just `"ab"`, denotes
; any sequence of terminals among
; '65 66',
; '65 98',
; '97 66', and
; '97 98'.
; [65, 66],
; [65, 98],
; [97, 66], and
; [97, 98].
; ABNF terminals in suitable sets represent ASCII or Unicode characters.
; ABNF allows repetition prefixes n*m,
; where n and m are natural numbers in decimal notation;
; ABNF allows repetition prefixes `n*m`,
; where `n` and `m` are natural numbers in decimal notation;
; if absent,
; n defaults to 0, and
; m defaults to infinity.
; `n` defaults to 0, and
; `m` defaults to infinity.
; For example,
; 1*4HEXDIG denotes one to four HEXDIGs,
; *3DIGIT denotes up to three DIGITs, and
; 1*OCTET denotes one or more OCTETs.
; A single n prefix
; abbreviates n*n,
; e.g. 3DIGIT denotes three DIGITs.
; `1*4HEXDIG` denotes one to four `HEXDIG`s,
; `*3DIGIT` denotes up to three `DIGIT`s, and
; `1*OCTET` denotes one or more `OCTET`s.
; A single `n` prefix
; abbreviates `n*n`,
; e.g. `3DIGIT` denotes three `DIGIT`s.
; Instead of BNF's |, ABNF uses / to separate alternatives.
; Instead of BNF's `|`, ABNF uses `/` to separate alternatives.
; Repetition prefixes have precedence over juxtapositions,
; which have precedence over /.
; which have precedence over `/`.
; Round brackets group things and override the aforementioned precedence rules,
; e.g. *(WSP / CRLF WSP) denotes sequences of terminals
; e.g. `*(WSP / CRLF WSP)` denotes sequences of terminals
; obtained by repeating, zero or more times,
; either (i) a WSP or (ii) a CRLF followed by a WSP.
; either (i) a `WSP` or (ii) a `CRLF` followed by a `WSP`.
; Square brackets also group things but make them optional,
; e.g. [":" port] is equivalent to 0*1(":" port).
; e.g. `[":" port]` is equivalent to `0*1(":" port)`.
; Instead of BNF's ::=, ABNF uses = to define nonterminals,
; and =/ to incrementally add alternatives
; Instead of BNF's `::=`, ABNF uses `=` to define nonterminals,
; and `=/` to incrementally add alternatives
; to previously defined nonterminals.
; For example, the rule BIT = "0" / "1"
; is equivalent to BIT = "0" followed by BIT =/ "1".
; For example, the rule `BIT = "0" / "1"`
; is equivalent to `BIT = "0"` followed by `BIT =/ "1"`.
; The syntax of ABNF itself is formally specified in ABNF
; (in Section 4 of the aforementioned RFC 5234,
@ -125,7 +125,7 @@
; This ABNF grammar consists of two (sub-)grammars:
; (i) a lexical grammar that describes how
; sequence of characters are parsed into tokens, and
; (ii) a syntactic grammar that described how
; (ii) a syntactic grammar that describes how
; tokens are parsed into expressions, statements, etc.
; The adjectives 'lexical' and 'syntactic' are
; the same ones used in the Java language reference,
@ -180,8 +180,8 @@
; / additive-expression "-" multiplicative-expression
;
; These rules tell us
; that the additive operators '+' and '-' have lower precedence
; than the multiplicative operators '*' and '/',
; that the additive operators `+` and `-` have lower precedence
; than the multiplicative operators `*` and `/`,
; and that both the additive and multiplicative operators associate to the left.
; This may be best understood via the examples given below.
@ -239,7 +239,7 @@
; This ABNF grammar uses nonterminal names
; that consist of complete English words, separated by dashes,
; and that describe the construct the way it is in English.
; For instance, we use the name 'conditional-statement'
; For instance, we use the name `conditional-statement`
; to describe conditional statements.
; At the same time, this grammar establishes
@ -284,8 +284,8 @@
; A Leo file is a finite sequence of Unicode characters,
; represented as Unicode code points,
; which are numbers in the range form 0 to 10FFFFh.
; These are captured by the ABNF rule 'character' below.
; which are numbers in the range from 0 to 10FFFFh.
; These are captured by the ABNF rule `character` below.
; The lexical grammar defines how, at least conceptually,
; the sequence of characters is turned into
@ -293,20 +293,20 @@
; these entities are all defined by the grammar rules below.
; As stated, the lexical grammar alone is ambiguous.
; For example, the sequence of characters '**' (i.e. two stars)
; could be equally parsed as two '*' symbol tokens or one '**' symbol token
; (see rule for 'symbol' below).
; As another example, the sequence or characters '<CR><LF>'
; For example, the sequence of characters `**` (i.e. two stars)
; could be equally parsed as two `*` symbol tokens or one `**` symbol token
; (see rule for `symbol` below).
; As another example, the sequence or characters `<CR><LF>`
; (i.e. carriage return followed by line feed)
; could be equally parsed as two line terminators or one
; (see rule for 'newline').
; (see rule for `newline`).
; Thus, as often done in language syntax definitions,
; the lexical grammar is disambiguated by
; the extra-grammatical requirement that
; the longest possible sequence of characters is always parsed.
; This way, '**' must be parsed as one '**' symbol token,
; and '<CR><LF>' must be parsed as one line terminator.
; This way, `**` must be parsed as one `**` symbol token,
; and `<CR><LF>` must be parsed as one line terminator.
; As mentioned above, a character is any Unicode code point.
; This grammar does not say how those are encoded in files (e.g. UTF-8):
@ -318,15 +318,15 @@ character = %x0-10FFFF ; any Unicode code point
; We give names to certain ASCII characters.
horizontal-tab = %x9
horizontal-tab = %x9 ; <HT>
line-feed = %xA
line-feed = %xA ; <LF>
carriage-return = %xD
carriage-return = %xD ; <CR>
space = %x20
space = %x20 ; <SP>
double-quote = %x22
double-quote = %x22 ; "
; We give names to complements of certain ASCII characters.
; These consist of all the Unicode characters except for one or two.
@ -336,9 +336,16 @@ not-double-quote = %x0-22 / %x24-10FFFF ; anything but "
not-star = %x0-29 / %x2B-10FFFF ; anything but *
not-line-feed-or-carriage-return = %x0-9 / %xB-C / %xE-10FFFF
; anything but LF or CR
; anything but <LF> or <CR>
not-star-or-slash = %x0-29 / %x2B-2E / %x30-10FFFF ; anything but * or /
not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
; anything but " or {
not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
; anything but " or }
not-star-or-slash = %x0-29 / %x2B-2E / %x30-10FFFF
; anything but * or /
; Lines in Leo may be terminated via
; a single carriage return,
@ -355,12 +362,12 @@ newline = line-feed / carriage-return / carriage-return line-feed
whitespace = space / horizontal-tab / newline
; There are two kinds of comments in Leo, as in other languages.
; One is block comments of the form '/* ... */',
; and the other is end-of-line comments of the form '// ...'.
; The first kind start at '/*' and end at the first '*/',
; One is block comments of the form `/* ... */`,
; and the other is end-of-line comments of the form `// ...`.
; The first kind start at `/*` and end at the first `*/`,
; possibly spanning multiple (partial) lines;
; these do no nest.
; The second kind start at '//' and extend till the end of the line.
; The second kind start at `//` and extend till the end of the line.
; The rules about comments given below are similar to
; the ones used in the Java language reference.
@ -440,57 +447,30 @@ package-name = 1*( lowercase-letter / digit )
; A format string is a sequence of characters, other than double quote,
; surrounded by double quotes.
; Within a format string, sub-strings '{}' are distinguished as containers
; Within a format string, sub-strings `{}` are distinguished as containers
; (these are the ones that may be matched with values
; whose textual representation replaces the containers
; in the printed string).
; There is an implicit extra-grammatical requirements that
; the explicit 'format-string-container' instances include
; all the occurrences of '{}' in the parsed character sequence:
; that is, there may not be two contiguous 'not-double-quote' instances
; that are '{' and '}'.
format-string-container = "{}"
not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
format-string-element = not-double-quote-or-open-brace
/ "{" not-double-quote-or-close-brace
/ format-string-container
format-string = double-quote *format-string-element double-quote
; Here is (part of this ABNF comment),
; an alternative way to specify format strings,
; which captures the extra-grammatical requirement above in the grammar,
; but is more complicated:
;
; not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
;
; not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
;
; format-string-element = not-double-quote-or-open-brace
; / "{" not-double-quote-or-close-brace
; / format-string-container
;
; format-string = double-quote *format-string-element double-quote
;
; It is not immediately clear which approach is better; there are tradeoffs.
; We may choose to adopt this one in future revisions of the grammar.
; Annotations have names, which are identifiers immediately preceded by '@'.
; Annotations have names, which are identifiers immediately preceded by `@`.
annotation-name = "@" identifier
; A natural (number) is a sequence of one or more digits.
; We allow leading zeros, e.g. '007'.
; We allow leading zeros, e.g. `007`.
natural = 1*digit
; An integer (number) is either a natural or its negation.
; We allow leading zeros also in negative numbers, e.g. '-007'.
; We allow leading zeros also in negative numbers, e.g. `-007`.
integer = [ "-" ] natural
@ -522,7 +502,7 @@ product-group-literal = integer %s"group"
boolean-literal = %s"true" / %s"false"
; An address literal starts with 'aleo1'
; An address literal starts with `aleo1`
; and continues with exactly 58 lowercase letters and digits.
; Thus an address always consists of 63 characters.
@ -541,12 +521,12 @@ atomic-literal = untyped-literal
/ address-literal
; After defining the (mostly) alphanumeric tokens above,
; it remains to define tokens for non-alphanumeric symbols such as "+" and "(".
; it remains to define tokens for non-alphanumeric symbols such as `+` and `(`.
; Different programming languages used different terminologies for these,
; e.g. operators, separators, punctuators, etc.
; Here we use 'symbol', for all of them.
; Here we use `symbol`, for all of them.
; We also include a token consisting of
; a closing parenthesis immediately followed by 'group':
; a closing parenthesis `)` immediately followed by `group`:
; as defined in the syntactic grammar,
; this is the final part of an affine group literal;
; even though it includes letters,
@ -558,7 +538,7 @@ atomic-literal = untyped-literal
;
; equality-operator = "=="
;
; and defining 'symbol' in terms of those
; and defining `symbol` in terms of those
;
; symbol = ... / equality-operator / ...
;
@ -567,7 +547,7 @@ atomic-literal = untyped-literal
; namely the exact names of some of these token.
; On the other hand, at least some of them are perhaps simple enough
; that they could be just described in terms of their symbols,
; e.g. 'double dot', 'question mark', etc.
; e.g. double dot, question mark, etc.
symbol = "!" / "&&" / "||"
/ "==" / "!="
@ -632,7 +612,7 @@ address-type = %s"address"
scalar-type = boolean-type / arithmetic-type / address-type
; Circuit types are denoted by identifiers and the keyword 'Self'.
; Circuit types are denoted by identifiers and the keyword `Self`.
; The latter is only allowed inside a circuit definition,
; to denote the circuit being defined.
@ -683,7 +663,7 @@ affine-group-literal = "(" group-coordinate "," group-coordinate %s")group"
literal = atomic-literal / affine-group-literal
; The following rule is not directly referenced in the rules for expressions
; (which reference 'literal' instead),
; (which reference `literal` instead),
; but it is useful to establish terminology:
; a group literal is either a product group literal or an affine group literal.
@ -722,7 +702,7 @@ tuple-expression = tuple-construction
; Array expressions construct arrays.
; There are two kinds:
; one lists the element expressions (at least one),
; including spreads (via '...') which are arrays being spliced in;
; including spreads (via `...`) which are arrays being spliced in;
; the other repeats (the value of) a single expression
; across one or more dimensions.
@ -749,7 +729,8 @@ array-expression = array-construction
; so they are syntactically identical but semantically different.
circuit-construction = circuit-type "{"
circuit-inline-element *( "," circuit-inline-element ) [ "," ]
circuit-inline-element
*( "," circuit-inline-element ) [ "," ]
"}"
circuit-inline-element = identifier ":" expression / identifier
@ -797,8 +778,8 @@ unary-expression = postfix-expression
; Next in the operator precedence is exponentiation,
; following mathematical practice.
; The current rule below makes exponentiation left-associative,
; i.e. 'a ** b ** c' must be parsed as '(a ** b) ** c'.
; The current rule below makes exponentiation right-associative,
; i.e. `a ** b ** c` must be parsed as `a ** (b ** c)`.
exponential-expression = unary-expression
/ unary-expression "**" exponential-expression
@ -875,8 +856,7 @@ block = "{" *statement "}"
expression-statement = expression ";"
; A return statement always takes an expression,
; and does not end with a semicolon.
; A return statement always takes an expression, and ends with a semicolon.
return-statement = %s"return" expression ";"
@ -912,20 +892,20 @@ conditional-statement = branch
loop-statement = %s"for" identifier %s"in" expression ".." expression block
; An assignment statement is straightforward.
; Based on the operator, the assignment may be simple (i.e. '=')
; Based on the operator, the assignment may be simple (i.e. `=`)
; or compound (i.e. combining assignment with an arithmetic operation).
assignment-operator = "=" / "+=" / "-=" / "*=" / "/=" / "**="
assignment-statement = expression assignment-operator expression ";"
; Console statements start with the 'console' keyword,
; Console statements start with the `console` keyword,
; followed by a console function call.
; The call may be an assertion or a print command.
; The former takes an expression (which must be boolean) as argument.
; The latter takes either no argument,
; or a format string followed by expressions,
; whose number must match the number of containers '{}' in the format string.
; whose number must match the number of containers `{}` in the format string.
; Note that the console function names are identifiers, not keywords.
; There are three kinds of print commands.
@ -942,7 +922,7 @@ print-arguments = "(" [ format-string *( "," expression ) ] ")"
print-call = print-function print-arguments
; An annotation consists of an annotation name (which starts with '@')
; An annotation consists of an annotation name (which starts with `@`)
; with optional annotation arguments, which are identifiers.
; Note that no parentheses are used if there are no arguments.
@ -954,8 +934,7 @@ annotation = annotation-name
; In general, a function input consists of an identifier and a type,
; with an optional 'const' modifier.
; Additionally, functions inside circuits
; may start with a 'mut self' or 'const self' or 'self' parameter.
; Furthermore, any function may end with an 'input' parameter.
; may start with a `mut self` or `const self` or `self` parameter.
function-declaration = *annotation %s"function" identifier
"(" [ function-parameters ] ")" [ "->" type ]
@ -971,8 +950,6 @@ function-inputs = function-input *( "," function-input )
function-input = [ %s"const" ] identifier ":" type
input-parameter = %s"input"
; A circuit member variable declaration consists of an identifier and a type.
; A circuit member function declaration consists of a function declaration.
@ -989,7 +966,7 @@ member-function-declaration = function-declaration
circuit-declaration = *annotation %s"circuit" identifier
"{" member-declaration *( "," member-declaration ) "}"
; An import declaration consists of the 'import' keyword
; An import declaration consists of the `import` keyword
; followed by a package path, which may be one of the following:
; a single wildcard;
; an identifier, optionally followed by a local renamer;
@ -1019,16 +996,18 @@ file = *declaration
; Format Note
; -----------
; The ABNF standard requires grammars to consist of lines terminated by CR LF
; The ABNF standard requires grammars
; to consist of lines terminated by `<CR><LF>`
; (i.e. carriage return followed by line feed, DOS/Windows-style),
; as explained in the background on ABNF earlier in this file.
; This file's lines are therefore terminated by CR LF.
; This file's lines are therefore terminated by `<CR><LF>`.
; To avoid losing this requirement across systems,
; this file is marked as 'text eol=crlf' in .gitattributes:
; this file is marked as `text eol=crlf` in `.gitattributes`:
; this means that the file is textual, enabling visual diffs,
; but its lines will always be terminated by CR LF on any system.
; but its lines will always be terminated by `<CR><LF>` on any system.
; Note that this CR LF requirement only applies to the grammar files themselves.
; Note that this `<CR><LF>` requirement only applies
; to the grammar files themselves.
; It does not apply to the lines of the languages described by the grammar.
; ABNF grammars may describe any kind of languages,
; with any kind of line terminators,

44
leo/api.rs
View File

@ -22,25 +22,24 @@ use reqwest::{
};
use serde::{Deserialize, Serialize};
/// Trait describes API Routes and Request bodies, struct which implements
/// Route MUST also support Serialize to be usable in Api::run_route(r: Route)
/// API Routes and Request bodies.
/// Structs that implement Route MUST also support Serialize to be usable in Api::run_route(r: Route)
pub trait Route {
/// Whether to use bearer auth or not. Some routes may have additional
/// features for logged-in users, so authorization token should be sent
/// if it is created of course
/// [`true`] if a route supports bearer authentication.
/// For example, the login route.
const AUTH: bool;
/// HTTP method to use when requesting
/// The HTTP method to use when requesting.
const METHOD: Method;
/// URL path without first forward slash (e.g. v1/package/fetch)
/// The URL path without the first forward slash (e.g. v1/package/fetch)
const PATH: &'static str;
/// Output type for this route. For login it is simple - String
/// The output type for this route. For example, the login route output is [`String`].
/// But for other routes may be more complex.
type Output;
/// Process reqwest Response and turn it into Output
/// Process the reqwest Response and turn it into an Output.
fn process(&self, res: Response) -> Result<Self::Output>;
/// Transform specific status codes into correct errors for this route.
@ -50,18 +49,18 @@ pub trait Route {
}
}
/// REST API handler with reqwest::blocking inside
/// REST API handler with reqwest::blocking inside.
#[derive(Clone, Debug)]
pub struct Api {
host: String,
client: Client,
/// Authorization token for API requests
/// Authorization token for API requests.
auth_token: Option<String>,
}
impl Api {
/// Create new instance of API, set host and Client is going to be
/// created and set automatically
/// Returns a new instance of API.
/// The set host and Client are created automatically.
pub fn new(host: String, auth_token: Option<String>) -> Api {
Api {
client: Client::new(),
@ -70,18 +69,23 @@ impl Api {
}
}
/// Get token for bearer auth, should be passed into Api through Context
pub fn host(&self) -> &str {
&*self.host
}
/// Returns the token for bearer auth, otherwise None.
/// The [`auth_token`] should be passed into the Api through Context.
pub fn auth_token(&self) -> Option<String> {
self.auth_token.clone()
}
/// Set authorization token for future requests
/// Set the authorization token for future requests.
pub fn set_auth_token(&mut self, token: String) {
self.auth_token = Some(token);
}
/// Run specific route struct. Turn struct into request body
/// and use type constants and Route implementation to get request params
/// and use type constants and Route implementation to get request params.
pub fn run_route<T>(&self, route: T) -> Result<T::Output>
where
T: Route,
@ -100,7 +104,9 @@ impl Api {
};
// only one error is possible here
let res = res.send().map_err(|_| anyhow!("Unable to connect to Aleo PM"))?;
let res = res.send().map_err(|_| {
anyhow!("Unable to connect to Aleo PM. If you specified custom API endpoint, then check the URL for errors")
})?;
// where magic begins
route.process(res)
@ -143,7 +149,7 @@ impl Route for Fetch {
// TODO: we should return 404 on not found author/package
// and return BAD_REQUEST if data format is incorrect or some of the arguments
// were not passed
StatusCode::NOT_FOUND => anyhow!("Package is hidden"),
StatusCode::NOT_FOUND => anyhow!("Package not found"),
_ => anyhow!("Unknown API error: {}", status),
}
}
@ -183,7 +189,7 @@ impl Route for Login {
}
/// Handler for 'my_profile' route. Meant to be used to get profile details but
/// in current application is used to check if user is logged in. Any non-200 response
/// in the current application it is used to check if the user is logged in. Any non-200 response
/// is treated as Unauthorized.
#[derive(Serialize)]
pub struct Profile {}

200
leo/commands/build.rs
View File

@ -22,11 +22,11 @@ use leo_compiler::{
use leo_package::{
inputs::*,
outputs::{ChecksumFile, CircuitFile, OutputsDirectory, OUTPUTS_DIRECTORY_NAME},
source::{LibraryFile, MainFile, LIBRARY_FILENAME, MAIN_FILENAME, SOURCE_DIRECTORY_NAME},
source::{MainFile, MAIN_FILENAME, SOURCE_DIRECTORY_NAME},
};
use leo_synthesizer::{CircuitSynthesizer, SerializedCircuit};
use anyhow::Result;
use anyhow::{anyhow, Result};
use snarkvm_curves::{bls12_377::Bls12_377, edwards_bls12::Fq};
use snarkvm_r1cs::ConstraintSystem;
use structopt::StructOpt;
@ -39,7 +39,7 @@ pub struct Build {}
impl Command for Build {
type Input = ();
type Output = Option<(Compiler<'static, Fq, EdwardsGroupType>, bool)>;
type Output = (Compiler<'static, Fq, EdwardsGroupType>, bool);
fn log_span(&self) -> Span {
tracing::span!(tracing::Level::INFO, "Build")
@ -65,115 +65,95 @@ impl Command for Build {
tracing::info!("Starting...");
// Compile the package starting with the lib.leo file
if LibraryFile::exists_at(&package_path) {
// Construct the path to the library file in the source directory
let mut lib_file_path = package_path.clone();
lib_file_path.push(SOURCE_DIRECTORY_NAME);
lib_file_path.push(LIBRARY_FILENAME);
// Log compilation of library file to console
tracing::info!("Compiling library... ({:?})", lib_file_path);
// Compile the library file but do not output
let _program = Compiler::<Fq, EdwardsGroupType>::parse_program_without_input(
package_name.clone(),
lib_file_path,
output_directory.clone(),
thread_leaked_context(),
)?;
tracing::info!("Complete");
};
// Compile the main.leo file along with constraints
if MainFile::exists_at(&package_path) {
// Create the output directory
OutputsDirectory::create(&package_path)?;
// Construct the path to the main file in the source directory
let mut main_file_path = package_path.clone();
main_file_path.push(SOURCE_DIRECTORY_NAME);
main_file_path.push(MAIN_FILENAME);
// Load the input file at `package_name.in`
let (input_string, input_path) = InputFile::new(&package_name).read_from(&path)?;
// Load the state file at `package_name.in`
let (state_string, state_path) = StateFile::new(&package_name).read_from(&path)?;
// Log compilation of files to console
tracing::info!("Compiling main program... ({:?})", main_file_path);
// Load the program at `main_file_path`
let program = Compiler::<Fq, EdwardsGroupType>::parse_program_with_input(
package_name.clone(),
main_file_path,
output_directory,
&input_string,
&input_path,
&state_string,
&state_path,
thread_leaked_context(),
)?;
// Compute the current program checksum
let program_checksum = program.checksum()?;
// Generate the program on the constraint system and verify correctness
{
let mut cs = CircuitSynthesizer::<Bls12_377> {
constraints: Default::default(),
public_variables: Default::default(),
private_variables: Default::default(),
namespaces: Default::default(),
};
let temporary_program = program.clone();
let output = temporary_program.compile_constraints(&mut cs)?;
tracing::debug!("Compiled output - {:#?}", output);
tracing::info!("Number of constraints - {:#?}", cs.num_constraints());
// Serialize the circuit
let circuit_object = SerializedCircuit::from(cs);
let json = circuit_object.to_json_string().unwrap();
// println!("json: {}", json);
// Write serialized circuit to circuit `.json` file.
let circuit_file = CircuitFile::new(&package_name);
circuit_file.write_to(&path, json)?;
// Check that we can read the serialized circuit file
// let serialized = circuit_file.read_from(&package_path)?;
// Deserialize the circuit
// let deserialized = SerializedCircuit::from_json_string(&serialized).unwrap();
// let _circuit_synthesizer = CircuitSynthesizer::<Bls12_377>::try_from(deserialized).unwrap();
// println!("deserialized {:?}", circuit_synthesizer.num_constraints());
}
// If a checksum file exists, check if it differs from the new checksum
let checksum_file = ChecksumFile::new(&package_name);
let checksum_differs = if checksum_file.exists_at(&package_path) {
let previous_checksum = checksum_file.read_from(&package_path)?;
program_checksum != previous_checksum
} else {
// By default, the checksum differs if there is no checksum to compare against
true
};
// If checksum differs, compile the program
if checksum_differs {
// Write the new checksum to the output directory
checksum_file.write_to(&path, program_checksum)?;
tracing::debug!("Checksum saved ({:?})", path);
}
tracing::info!("Complete");
return Ok(Some((program, checksum_differs)));
if !MainFile::exists_at(&package_path) {
return Err(anyhow!("File main.leo not found in src/ directory"));
}
Ok(None)
// Create the output directory
OutputsDirectory::create(&package_path)?;
// Construct the path to the main file in the source directory
let mut main_file_path = package_path.clone();
main_file_path.push(SOURCE_DIRECTORY_NAME);
main_file_path.push(MAIN_FILENAME);
// Load the input file at `package_name.in`
let (input_string, input_path) = InputFile::new(&package_name).read_from(&path)?;
// Load the state file at `package_name.in`
let (state_string, state_path) = StateFile::new(&package_name).read_from(&path)?;
// Log compilation of files to console
tracing::info!("Compiling main program... ({:?})", main_file_path);
// Load the program at `main_file_path`
let program = Compiler::<Fq, EdwardsGroupType>::parse_program_with_input(
package_name.clone(),
main_file_path,
output_directory,
&input_string,
&input_path,
&state_string,
&state_path,
thread_leaked_context(),
)?;
// Compute the current program checksum
let program_checksum = program.checksum()?;
// Generate the program on the constraint system and verify correctness
{
let mut cs = CircuitSynthesizer::<Bls12_377> {
constraints: Default::default(),
public_variables: Default::default(),
private_variables: Default::default(),
namespaces: Default::default(),
};
let temporary_program = program.clone();
let output = temporary_program.compile_constraints(&mut cs)?;
tracing::debug!("Compiled output - {:#?}", output);
tracing::info!("Number of constraints - {:#?}", cs.num_constraints());
// Serialize the circuit
let circuit_object = SerializedCircuit::from(cs);
let json = circuit_object.to_json_string().unwrap();
// println!("json: {}", json);
// Write serialized circuit to circuit `.json` file.
let circuit_file = CircuitFile::new(&package_name);
circuit_file.write_to(&path, json)?;
// Check that we can read the serialized circuit file
// let serialized = circuit_file.read_from(&package_path)?;
// Deserialize the circuit
// let deserialized = SerializedCircuit::from_json_string(&serialized).unwrap();
// let _circuit_synthesizer = CircuitSynthesizer::<Bls12_377>::try_from(deserialized).unwrap();
// println!("deserialized {:?}", circuit_synthesizer.num_constraints());
}
// If a checksum file exists, check if it differs from the new checksum
let checksum_file = ChecksumFile::new(&package_name);
let checksum_differs = if checksum_file.exists_at(&package_path) {
let previous_checksum = checksum_file.read_from(&package_path)?;
program_checksum != previous_checksum
} else {
// By default, the checksum differs if there is no checksum to compare against
true
};
// If checksum differs, compile the program
if checksum_differs {
// Write the new checksum to the output directory
checksum_file.write_to(&path, program_checksum)?;
tracing::debug!("Checksum saved ({:?})", path);
}
tracing::info!("Complete");
Ok((program, checksum_differs))
}
}

9
leo/commands/init.rs
View File

@ -18,7 +18,6 @@ use crate::{commands::Command, config::*, context::Context};
use leo_package::LeoPackage;
use anyhow::{anyhow, Result};
use std::env::current_dir;
use structopt::StructOpt;
use tracing::span::Span;
@ -39,9 +38,9 @@ impl Command for Init {
Ok(())
}
fn apply(self, _: Context, _: Self::Input) -> Result<Self::Output> {
fn apply(self, context: Context, _: Self::Input) -> Result<Self::Output> {
// Derive the package directory path.
let path = current_dir()?;
let path = context.dir()?;
// Check that the current package directory path exists.
if !path.exists() {
@ -55,12 +54,12 @@ impl Command for Init {
.to_string_lossy()
.to_string();
if !LeoPackage::is_package_name_valid(&package_name) {
return Err(anyhow!("Invalid Leo project name"));
return Err(anyhow!("Invalid Leo project name: {}", package_name));
}
let username = read_username().ok();
LeoPackage::initialize(&package_name, false, &path, username)?;
LeoPackage::initialize(&package_name, &path, username)?;
Ok(())
}

8
leo/commands/new.rs
View File

@ -18,7 +18,7 @@ use crate::{commands::Command, config::*, context::Context};
use leo_package::LeoPackage;
use anyhow::{anyhow, Result};
use std::{env::current_dir, fs};
use std::fs;
use structopt::StructOpt;
use tracing::span::Span;
@ -42,7 +42,7 @@ impl Command for New {
Ok(())
}
fn apply(self, _: Context, _: Self::Input) -> Result<Self::Output> {
fn apply(self, context: Context, _: Self::Input) -> Result<Self::Output> {
// Check that the given package name is valid.
let package_name = self.name;
if !LeoPackage::is_package_name_valid(&package_name) {
@ -52,7 +52,7 @@ impl Command for New {
let username = read_username().ok();
// Derive the package directory path.
let mut path = current_dir()?;
let mut path = context.dir()?;
path.push(&package_name);
// Verify the package directory path does not exist yet.
@ -63,7 +63,7 @@ impl Command for New {
// Create the package directory
fs::create_dir_all(&path).map_err(|err| anyhow!("Could not create directory {}", err))?;
LeoPackage::initialize(&package_name, false, &path, username)?;
LeoPackage::initialize(&package_name, &path, username)?;
Ok(())
}

7
leo/commands/package/publish.rs
View File

@ -15,10 +15,7 @@
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use super::build::Build;
use crate::{
commands::Command,
context::{Context, PACKAGE_MANAGER_URL},
};
use crate::{commands::Command, context::Context};
use leo_package::{
outputs::OutputsDirectory,
root::{ZipFile, AUTHOR_PLACEHOLDER},
@ -118,7 +115,7 @@ impl Command for Publish {
// Make a request to publish a package
let response = client
.post(format!("{}{}", PACKAGE_MANAGER_URL, PUBLISH_URL).as_str())
.post(format!("{}{}", context.api.host(), PUBLISH_URL).as_str())
.headers(headers)
.multipart(form_data)
.send();

3
leo/commands/setup.rs
View File

@ -58,8 +58,7 @@ impl Command for Setup {
let package_name = context.manifest()?.get_package_name();
// Check if leo build failed
let (program, checksum_differs) =
input.ok_or_else(|| anyhow!("Unable to build, check that main file exists"))?;
let (program, checksum_differs) = input;
// Check if a proving key and verification key already exists
let keys_exist = ProvingKeyFile::new(&package_name).exists_at(&path)

2
leo/commands/update.rs
View File

@ -21,7 +21,7 @@ use structopt::StructOpt;
use tracing::span::Span;
/// Setting for automatic updates of Leo
#[derive(Debug, StructOpt, PartialEq)]
#[derive(Debug, StructOpt)]
pub enum Automatic {
Automatic {
#[structopt(name = "bool", help = "Boolean value: true or false", parse(try_from_str))]

9
leo/commands/watch.rs
View File

@ -65,13 +65,8 @@ impl Command for Watch {
// See changes on the write event
Ok(DebouncedEvent::Write(_write)) => {
match (Build {}).execute(context.clone()) {
Ok(_output) => {
tracing::info!("Built successfully");
}
Err(e) => {
// Syntax error
tracing::error!("Error {:?}", e);
}
Ok(_output) => tracing::info!("Built successfully"),
Err(e) => tracing::error!("Error {:?}", e),
};
}
// Other events

8
leo/context.rs
View File

@ -48,19 +48,19 @@ impl Context {
}
/// Create a new context for the current directory.
pub fn create_context(path: PathBuf) -> Result<Context> {
pub fn create_context(path: PathBuf, api_url: Option<String>) -> Result<Context> {
let token = config::read_token().ok();
let api = Api::new(PACKAGE_MANAGER_URL.to_string(), token);
let api = Api::new(api_url.unwrap_or_else(|| PACKAGE_MANAGER_URL.to_string()), token);
Ok(Context { api, path: Some(path) })
}
/// Returns project context.
pub fn get_context() -> Result<Context> {
pub fn get_context(api_url: Option<String>) -> Result<Context> {
let token = config::read_token().ok();
let api = Api::new(PACKAGE_MANAGER_URL.to_string(), token);
let api = Api::new(api_url.unwrap_or_else(|| PACKAGE_MANAGER_URL.to_string()), token);
Ok(Context { api, path: None })
}

9
leo/logger.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 std::fmt;
use std::{fmt, sync::Once};
use colored::Colorize;
use tracing::{event::Event, subscriber::Subscriber};
@ -24,6 +24,8 @@ use tracing_subscriber::{
FmtSubscriber,
};
static START: Once = Once::new();
#[derive(Debug, Clone)]
pub struct Format<F = Full, T = SystemTime> {
format: F,
@ -220,5 +222,8 @@ pub fn init_logger(_app_name: &'static str, verbosity: usize) {
.event_format(Format::default())
.finish();
tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
// call this line only once per process. needed for tests using same thread
START.call_once(|| {
tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
});
}

154
leo/main.rs
View File

@ -55,6 +55,9 @@ struct Opt {
#[structopt(subcommand)]
command: CommandOpts,
#[structopt(help = "Custom Aleo PM backend URL", env = "APM_URL")]
api: Option<String>,
#[structopt(
long,
global = true,
@ -178,9 +181,11 @@ enum CommandOpts {
}
fn main() {
// Read command line arguments.
let opt = Opt::from_args();
handle_error(run_with_args(Opt::from_args()))
}
/// Run command with custom build arguments.
fn run_with_args(opt: Opt) -> Result<(), Error> {
if !opt.quiet {
// Init logger with optional debug flag.
logger::init_logger("leo", match opt.debug {
@ -192,11 +197,11 @@ fn main() {
// Get custom root folder and create context for it.
// If not specified, default context will be created in cwd.
let context = handle_error(match opt.path {
Some(path) => context::create_context(path),
None => context::get_context(),
Some(path) => context::create_context(path, opt.api),
None => context::get_context(opt.api),
});
handle_error(match opt.command {
match opt.command {
CommandOpts::Init { command } => command.try_execute(context),
CommandOpts::New { command } => command.try_execute(context),
CommandOpts::Build { command } => command.try_execute(context),
@ -217,7 +222,7 @@ fn main() {
CommandOpts::Lint { command } => command.try_execute(context),
CommandOpts::Deploy { command } => command.try_execute(context),
});
}
}
fn handle_error<T>(res: Result<T, Error>) -> T {
@ -229,3 +234,140 @@ fn handle_error<T>(res: Result<T, Error>) -> T {
}
}
}
#[cfg(test)]
mod cli_tests {
use crate::{run_with_args, Opt};
use anyhow::Error;
use std::path::PathBuf;
use structopt::StructOpt;
use test_dir::{DirBuilder, FileType, TestDir};
// Runs Command from cmd-like argument "leo run --arg1 --arg2".
fn run_cmd(args: &str, path: &Option<PathBuf>) -> Result<(), Error> {
let args = args.split(' ').collect::<Vec<&str>>();
let mut opts = Opt::from_iter_safe(args)?;
if path.is_some() {
opts.path = path.clone();
}
if !opts.debug {
// turn off tracing for all tests
opts.quiet = true;
}
run_with_args(opts)
}
// Create a test directory with name.
fn testdir(name: &str) -> TestDir {
TestDir::temp().create(name, FileType::Dir)
}
#[test]
fn global_options() {
let path = Some(PathBuf::from("examples/pedersen-hash"));
assert!(run_cmd("leo build", &path).is_ok());
assert!(run_cmd("leo -q build", &path).is_ok());
assert!(run_cmd("leo --path ../../examples/no-directory-there build", &None).is_err());
assert!(run_cmd("leo -v build", &None).is_err());
}
#[test]
fn global_options_fail() {
assert!(run_cmd("leo --path ../../examples/no-directory-there build", &None).is_err());
assert!(run_cmd("leo -v build", &None).is_err());
}
#[test]
fn init() {
let dir = testdir("test");
let path = Some(dir.path("test"));
assert!(run_cmd("leo init", &path).is_ok());
assert!(run_cmd("leo init", &path).is_err()); // 2nd time
}
#[test]
fn init_fail() {
let dir = testdir("incorrect_name");
let path = Some(dir.path("incorrect_name"));
let fake = Some(PathBuf::from("no_such_directory"));
assert!(run_cmd("leo init", &fake).is_err());
assert!(run_cmd("leo init", &path).is_err());
}
#[test]
fn new() {
let dir = testdir("new");
let path = Some(dir.path("new"));
assert!(run_cmd("leo new test", &path).is_ok());
assert!(run_cmd("leo new test", &path).is_err()); // 2nd time
assert!(run_cmd("leo new wrong_name", &path).is_err());
}
#[test]
#[should_panic]
fn unimplemented() {
assert!(run_cmd("leo lint", &None).is_err());
assert!(run_cmd("leo deploy", &None).is_err());
}
#[test]
fn clean() {
let path = &Some(PathBuf::from("examples/pedersen-hash"));
assert!(run_cmd("leo build", path).is_ok());
assert!(run_cmd("leo clean", path).is_ok());
}
#[test]
fn setup_prove_run_clean() {
let dir = testdir("test");
let path = dir.path("test");
assert!(run_cmd("leo new setup-test", &Some(path.clone())).is_ok());
let setup_path = &Some(path.join("setup-test"));
assert!(run_cmd("leo setup", setup_path).is_ok());
assert!(run_cmd("leo setup", setup_path).is_ok());
assert!(run_cmd("leo setup --skip-key-check", setup_path).is_ok());
assert!(run_cmd("leo prove --skip-key-check", setup_path).is_ok());
assert!(run_cmd("leo run --skip-key-check", setup_path).is_ok());
assert!(run_cmd("leo clean", setup_path).is_ok());
}
#[test]
fn test_missing_file() {
let dir = testdir("test");
let path = dir.path("test");
assert!(run_cmd("leo new test-file-missing", &Some(path.clone())).is_ok());
let path = path.join("test-file-missing");
let file = path.join("src/main.leo");
let path = Some(path);
assert!(run_cmd("leo test", &path).is_ok());
std::fs::remove_file(&file).unwrap();
assert!(run_cmd("leo test", &path).is_err());
}
#[test]
#[ignore] // ignore until imports path is fixed #875
fn test_sudoku() {
let path = &Some(PathBuf::from("examples/silly-sudoku"));
assert!(run_cmd("leo build", path).is_ok());
assert!(run_cmd("leo test", path).is_ok());
assert!(run_cmd("leo test -f src/lib.leo", path).is_ok());
assert!(run_cmd("leo test -f src/main.leo", path).is_ok());
}
}

5
leo/tests/mod.rs
View File

@ -14,9 +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/>.
use std::path::PathBuf;
use anyhow::Result;
use std::path::PathBuf;
use crate::{
commands::{
@ -152,7 +151,7 @@ pub fn leo_update_and_update_automatic() -> Result<()> {
/// Create context for Pedersen Hash example
fn context() -> Result<Context> {
let path = PathBuf::from(&PEDERSEN_HASH_PATH);
let context = create_context(path)?;
let context = create_context(path, None)?;
Ok(context)
}

9
package/src/lib.rs
View File

@ -33,13 +33,8 @@ pub struct LeoPackage;
impl LeoPackage {
/// Initializes a Leo package at the given path.
pub fn initialize(
package_name: &str,
is_lib: bool,
path: &Path,
author: Option<String>,
) -> Result<(), PackageError> {
package::Package::initialize(package_name, is_lib, path, author)
pub fn initialize(package_name: &str, path: &Path, author: Option<String>) -> Result<(), PackageError> {
package::Package::initialize(package_name, path, author)
}
/// Returns `true` if the given Leo package name is valid.

112
package/src/package.rs
View File

@ -19,7 +19,7 @@ use crate::{
imports::ImportsDirectory,
inputs::{InputFile, InputsDirectory, StateFile},
root::{Gitignore, Manifest, README},
source::{LibraryFile, MainFile, SourceDirectory},
source::{MainFile, SourceDirectory},
};
use serde::Deserialize;
@ -107,7 +107,7 @@ impl Package {
}
/// Returns `true` if a package is can be initialized at a given path.
pub fn can_initialize(package_name: &str, is_lib: bool, path: &Path) -> bool {
pub fn can_initialize(package_name: &str, path: &Path) -> bool {
// Check that the package name is valid.
if !Self::is_package_name_valid(package_name) {
return false;
@ -122,32 +122,24 @@ impl Package {
result = false;
}
if is_lib {
// Check if the library file already exists.
if LibraryFile::exists_at(path) {
existing_files.push(LibraryFile::filename());
result = false;
}
} else {
// Check if the input file already exists.
let input_file = InputFile::new(&package_name);
if input_file.exists_at(path) {
existing_files.push(input_file.filename());
result = false;
}
// Check if the input file already exists.
let input_file = InputFile::new(&package_name);
if input_file.exists_at(path) {
existing_files.push(input_file.filename());
result = false;
}
// Check if the state file already exists.
let state_file = StateFile::new(&package_name);
if state_file.exists_at(path) {
existing_files.push(state_file.filename());
result = false;
}
// Check if the state file already exists.
let state_file = StateFile::new(&package_name);
if state_file.exists_at(path) {
existing_files.push(state_file.filename());
result = false;
}
// Check if the main file already exists.
if MainFile::exists_at(path) {
existing_files.push(MainFile::filename());
result = false;
}
// Check if the main file already exists.
if MainFile::exists_at(path) {
existing_files.push(MainFile::filename());
result = false;
}
if !existing_files.is_empty() {
@ -158,7 +150,7 @@ impl Package {
}
/// Returns `true` if a package is initialized at the given path
pub fn is_initialized(package_name: &str, is_lib: bool, path: &Path) -> bool {
pub fn is_initialized(package_name: &str, path: &Path) -> bool {
// Check that the package name is valid.
if !Self::is_package_name_valid(package_name) {
return false;
@ -169,43 +161,31 @@ impl Package {
return false;
}
if is_lib {
// Check if the library file exists.
if !LibraryFile::exists_at(&path) {
return false;
}
} else {
// Check if the input file exists.
let input_file = InputFile::new(&package_name);
if !input_file.exists_at(&path) {
return false;
}
// Check if the input file exists.
let input_file = InputFile::new(&package_name);
if !input_file.exists_at(&path) {
return false;
}
// Check if the state file exists.
let state_file = StateFile::new(&package_name);
if !state_file.exists_at(&path) {
return false;
}
// Check if the state file exists.
let state_file = StateFile::new(&package_name);
if !state_file.exists_at(&path) {
return false;
}
// Check if the main file exists.
if !MainFile::exists_at(&path) {
return false;
}
// Check if the main file exists.
if !MainFile::exists_at(&path) {
return false;
}
true
}
/// Creates a package at the given path
pub fn initialize(
package_name: &str,
is_lib: bool,
path: &Path,
author: Option<String>,
) -> Result<(), PackageError> {
pub fn initialize(package_name: &str, path: &Path, author: Option<String>) -> Result<(), PackageError> {
// First, verify that this directory is not already initialized as a Leo package.
{
if !Self::can_initialize(package_name, is_lib, path) {
if !Self::can_initialize(package_name, path) {
return Err(PackageError::FailedToInitialize(
package_name.to_owned(),
path.as_os_str().to_owned(),
@ -232,27 +212,21 @@ impl Package {
// Create the source directory.
SourceDirectory::create(&path)?;
// Create a new library or binary file.
if is_lib {
// Create the library file in the source directory.
LibraryFile::new(&package_name).write_to(&path)?;
} else {
// Create the input directory.
InputsDirectory::create(&path)?;
// Create the input directory.
InputsDirectory::create(&path)?;
// Create the input file in the inputs directory.
InputFile::new(&package_name).write_to(&path)?;
// Create the input file in the inputs directory.
InputFile::new(&package_name).write_to(&path)?;
// Create the state file in the inputs directory.
StateFile::new(&package_name).write_to(&path)?;
// Create the state file in the inputs directory.
StateFile::new(&package_name).write_to(&path)?;
// Create the main file in the source directory.
MainFile::new(&package_name).write_to(&path)?;
}
// Create the main file in the source directory.
MainFile::new(&package_name).write_to(&path)?;
}
// Next, verify that a valid Leo package has been initialized in this directory
{
if !Self::is_initialized(package_name, is_lib, path) {
if !Self::is_initialized(package_name, path) {
return Err(PackageError::FailedToInitialize(
package_name.to_owned(),
path.as_os_str().to_owned(),

76
package/src/source/library.rs
View File

@ -1,76 +0,0 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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/>.
//! The `lib.leo` file.
use crate::{errors::LibraryFileError, source::directory::SOURCE_DIRECTORY_NAME};
use serde::Deserialize;
use std::{borrow::Cow, fs::File, io::Write, path::Path};
pub static LIBRARY_FILENAME: &str = "lib.leo";
#[derive(Deserialize)]
pub struct LibraryFile {
pub package_name: String,
}
impl LibraryFile {
pub fn new(package_name: &str) -> Self {
Self {
package_name: package_name.to_string(),
}
}
pub fn filename() -> String {
format!("{}{}", SOURCE_DIRECTORY_NAME, LIBRARY_FILENAME)
}
pub fn exists_at(path: &Path) -> bool {
let mut path = Cow::from(path);
if path.is_dir() {
if !path.ends_with(SOURCE_DIRECTORY_NAME) {
path.to_mut().push(SOURCE_DIRECTORY_NAME);
}
path.to_mut().push(LIBRARY_FILENAME);
}
path.exists()
}
pub fn write_to(self, path: &Path) -> Result<(), LibraryFileError> {
let mut path = Cow::from(path);
if path.is_dir() {
if !path.ends_with(SOURCE_DIRECTORY_NAME) {
path.to_mut().push(SOURCE_DIRECTORY_NAME);
}
path.to_mut().push(LIBRARY_FILENAME);
}
let mut file = File::create(&path)?;
Ok(file.write_all(self.template().as_bytes())?)
}
fn template(&self) -> String {
format!(
r#"// The '{}' library circuit.
circuit Foo {{
a: field
}}
"#,
self.package_name
)
}
}

3
package/src/source/mod.rs
View File

@ -17,8 +17,5 @@
pub mod directory;
pub use directory::*;
pub mod library;
pub use library::*;
pub mod main;
pub use main::*;

72
package/tests/initialize/initialize.rs
View File

@ -19,7 +19,7 @@ use leo_package::{
inputs::{InputFile, InputsDirectory, StateFile},
package::Package,
root::Manifest,
source::{LibraryFile, MainFile, SourceDirectory},
source::{MainFile, SourceDirectory},
};
const TEST_PACKAGE_NAME: &str = "test-package";
@ -29,13 +29,13 @@ fn initialize_valid_package() {
let test_directory = test_dir();
// Ensure a package can be initialized at the `test_directory`
assert!(Package::can_initialize(TEST_PACKAGE_NAME, false, &test_directory));
assert!(Package::can_initialize(TEST_PACKAGE_NAME, &test_directory));
// Initialize a package at the `test_directory`
assert!(Package::initialize(TEST_PACKAGE_NAME, false, &test_directory, None).is_ok());
assert!(Package::initialize(TEST_PACKAGE_NAME, &test_directory, None).is_ok());
// Ensure a package is initialized at the `test_directory`
assert!(Package::is_initialized(TEST_PACKAGE_NAME, false, &test_directory));
assert!(Package::is_initialized(TEST_PACKAGE_NAME, &test_directory));
}
#[test]
@ -43,21 +43,13 @@ fn initialize_valid_package_with_author() {
let test_directory = test_dir();
// Ensure a package can be initialized at the `test_directory`
assert!(Package::can_initialize(TEST_PACKAGE_NAME, false, &test_directory));
assert!(Package::can_initialize(TEST_PACKAGE_NAME, &test_directory));
// Initialize a package at the `test_directory`
assert!(
Package::initialize(
TEST_PACKAGE_NAME,
false,
&test_directory,
Some(String::from("test_user"))
)
.is_ok()
);
assert!(Package::initialize(TEST_PACKAGE_NAME, &test_directory, Some(String::from("test_user"))).is_ok());
// Ensure a package is initialized at the `test_directory`
assert!(Package::is_initialized(TEST_PACKAGE_NAME, false, &test_directory));
assert!(Package::is_initialized(TEST_PACKAGE_NAME, &test_directory));
}
#[test]
@ -71,7 +63,7 @@ fn initialize_fails_with_existing_manifest() {
let test_directory = test_dir();
// Ensure a package can be initialized at the `test_directory`
assert!(Package::can_initialize(TEST_PACKAGE_NAME, false, &test_directory));
assert!(Package::can_initialize(TEST_PACKAGE_NAME, &test_directory));
// Manually add a manifest file to the `test_directory`
Manifest::new(TEST_PACKAGE_NAME, None)
@ -80,28 +72,10 @@ fn initialize_fails_with_existing_manifest() {
.unwrap();
// Attempt to initialize a package at the `test_directory`
assert!(Package::initialize(TEST_PACKAGE_NAME, false, &test_directory, None).is_err());
assert!(Package::initialize(TEST_PACKAGE_NAME, &test_directory, None).is_err());
// Ensure package is not initialized at the `test_directory`
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, false, &test_directory));
}
#[test]
fn initialize_fails_with_existing_library_file() {
let test_directory = test_dir();
// Ensure a package can be initialized at the `test_directory`
assert!(Package::can_initialize(TEST_PACKAGE_NAME, true, &test_directory));
// Manually add a source directory and a library file to the `test_directory`
SourceDirectory::create(&test_directory).unwrap();
LibraryFile::new(TEST_PACKAGE_NAME).write_to(&test_directory).unwrap();
// Attempt to initialize a package at the `test_directory`
assert!(Package::initialize(TEST_PACKAGE_NAME, true, &test_directory, None).is_err());
// Ensure package is not initialized at the `test_directory`
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, true, &test_directory));
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, &test_directory));
}
#[test]
@ -109,25 +83,17 @@ fn initialize_fails_with_existing_input_file() {
let test_directory = test_dir();
// Ensure a package can be initialized at the `test_directory`
assert!(Package::can_initialize(TEST_PACKAGE_NAME, false, &test_directory));
assert!(Package::can_initialize(TEST_PACKAGE_NAME, &test_directory));
// Manually add an inputs directory and an input file to the `test_directory`
InputsDirectory::create(&test_directory).unwrap();
InputFile::new(TEST_PACKAGE_NAME).write_to(&test_directory).unwrap();
// Attempt to initialize a package at the `test_directory`
assert!(
Package::initialize(
TEST_PACKAGE_NAME,
false,
&test_directory,
Some(String::from("test_user"))
)
.is_err()
);
assert!(Package::initialize(TEST_PACKAGE_NAME, &test_directory, Some(String::from("test_user"))).is_err());
// Ensure package is not initialized at the `test_directory`
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, false, &test_directory));
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, &test_directory));
}
#[test]
@ -135,17 +101,17 @@ fn initialize_fails_with_existing_state_file() {
let test_directory = test_dir();
// Ensure a package can be initialized at the `test_directory`
assert!(Package::can_initialize(TEST_PACKAGE_NAME, false, &test_directory));
assert!(Package::can_initialize(TEST_PACKAGE_NAME, &test_directory));
// Manually add an inputs directory and a state file to the `test_directory`
InputsDirectory::create(&test_directory).unwrap();
StateFile::new(TEST_PACKAGE_NAME).write_to(&test_directory).unwrap();
// Attempt to initialize a package at the `test_directory`
assert!(Package::initialize(TEST_PACKAGE_NAME, false, &test_directory, None).is_err());
assert!(Package::initialize(TEST_PACKAGE_NAME, &test_directory, None).is_err());
// Ensure package is not initialized at the `test_directory`
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, false, &test_directory));
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, &test_directory));
}
#[test]
@ -153,15 +119,15 @@ fn initialize_fails_with_existing_main_file() {
let test_directory = test_dir();
// Ensure a package can be initialized at the `test_directory`
assert!(Package::can_initialize(TEST_PACKAGE_NAME, false, &test_directory));
assert!(Package::can_initialize(TEST_PACKAGE_NAME, &test_directory));
// Manually add a source directory and a main file to the `test_directory`
SourceDirectory::create(&test_directory).unwrap();
MainFile::new(TEST_PACKAGE_NAME).write_to(&test_directory).unwrap();
// Attempt to initialize a package at the `test_directory`
assert!(Package::initialize(TEST_PACKAGE_NAME, false, &test_directory, None).is_err());
assert!(Package::initialize(TEST_PACKAGE_NAME, &test_directory, None).is_err());
// Ensure package is not initialized at the `test_directory`
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, false, &test_directory));
assert!(!Package::is_initialized(TEST_PACKAGE_NAME, &test_directory));
}

4
parser/Cargo.toml
View File

@ -54,6 +54,10 @@ version = "0.3"
[dev-dependencies.serde_yaml]
version = "0.8"
[dev-dependencies.leo-test-framework]
path = "../test-framework"
version = "1.4.0"
[features]
default = [ ]
ci_skip = [ ]

614
parser/src/test.rs
View File

@ -14,158 +14,36 @@
// 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 std::{
fmt,
fs,
path::{Path, PathBuf},
sync::Arc,
};
use leo_ast::{Expression, ExpressionStatement, Program, Span, Statement, ValueExpression};
use leo_ast::{Expression, ExpressionStatement, Span, Statement, ValueExpression};
use leo_test_framework::runner::{Namespace, ParseType, Runner};
use serde_yaml::Value;
use tokenizer::Token;
use crate::{tokenizer, DeprecatedError, ParserContext, SyntaxError, TokenError};
use crate::{tokenizer, ParserContext};
struct TestFailure {
path: String,
errors: Vec<TestError>,
}
struct TokenNamespace;
#[derive(Debug)]
enum TestError {
UnexpectedOutput {
index: usize,
expected: String,
output: String,
},
PassedAndShouldntHave {
index: usize,
},
FailedAndShouldntHave {
index: usize,
error: String,
},
UnexpectedError {
index: usize,
expected: String,
output: String,
},
MismatchedTestExpectationLength,
}
impl fmt::Display for TestError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
TestError::UnexpectedOutput {
index,
expected,
output,
} => {
write!(f, "test #{} expected\n{}\ngot\n{}", index + 1, expected, output)
}
TestError::PassedAndShouldntHave { index } => write!(f, "test #{} passed and shouldn't have", index + 1),
TestError::FailedAndShouldntHave { index, error } => {
write!(f, "test #{} failed and shouldn't have:\n{}", index + 1, error)
}
TestError::UnexpectedError {
expected,
output,
index,
} => {
write!(f, "test #{} expected error\n{}\ngot\n{}", index + 1, expected, output)
}
TestError::MismatchedTestExpectationLength => write!(f, "invalid number of test expectations"),
}
impl Namespace for TokenNamespace {
fn parse_type(&self) -> ParseType {
ParseType::Line
}
}
pub fn find_tests<T: AsRef<Path>>(path: T, out: &mut Vec<(String, String)>) {
for entry in fs::read_dir(path).expect("fail to read tests").into_iter() {
let entry = entry.expect("fail to read tests").path();
if entry.is_dir() {
find_tests(entry.as_path(), out);
continue;
} else if entry.extension().map(|x| x.to_str()).flatten().unwrap_or_default() != "leo" {
continue;
}
let content = fs::read_to_string(entry.as_path()).expect("failed to read test");
out.push((entry.as_path().to_str().unwrap_or_default().to_string(), content));
fn run_test(&self, test: &str) -> Result<Value, String> {
let output = tokenizer::tokenize("test", test.into());
output
.map(|tokens| {
Value::String(
tokens
.into_iter()
.map(|x| x.to_string())
.collect::<Vec<String>>()
.join(","),
)
})
.map_err(|x| x.to_string())
}
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug, Clone)]
enum TestNamespace {
Parse,
ParseStatement,
ParseExpression,
Token,
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug, Clone)]
enum TestExpectationMode {
Pass,
Fail,
}
#[derive(serde::Serialize, serde::Deserialize)]
struct TestConfig {
namespace: TestNamespace,
expectation: TestExpectationMode,
}
#[derive(serde::Serialize, serde::Deserialize, Clone)]
struct TestExpectation {
namespace: TestNamespace,
expectation: TestExpectationMode,
outputs: Vec<Value>,
}
fn extract_test_config(source: &str) -> Option<TestConfig> {
let first_comment_start = source.find("/*")?;
let end_first_comment = source[first_comment_start + 2..].find("*/")?;
let comment_inner = &source[first_comment_start + 2..first_comment_start + 2 + end_first_comment];
Some(serde_yaml::from_str(comment_inner).expect("invalid test configuration"))
}
fn split_tests_oneline(source: &str) -> Vec<&str> {
source.lines().map(|x| x.trim()).filter(|x| !x.is_empty()).collect()
}
fn split_tests_twoline(source: &str) -> Vec<String> {
let mut out = vec![];
let mut lines = vec![];
for line in source.lines() {
let line = line.trim();
if line.is_empty() {
if !lines.is_empty() {
out.push(lines.join("\n"));
}
lines.clear();
continue;
}
lines.push(line);
}
let last_test = lines.join("\n");
if !last_test.trim().is_empty() {
out.push(last_test.trim().to_string());
}
out
}
fn run_individual_token_test(path: &str, source: &str) -> Result<String, String> {
let output = tokenizer::tokenize(path, source.into());
output
.map(|tokens| {
tokens
.into_iter()
.map(|x| x.to_string())
.collect::<Vec<String>>()
.join(",")
})
.map_err(|x| strip_path_syntax_error(x.into()))
}
fn not_fully_consumed(tokens: &mut ParserContext) -> Result<(), String> {
if !tokens.has_next() {
return Ok(());
@ -178,389 +56,95 @@ fn not_fully_consumed(tokens: &mut ParserContext) -> Result<(), String> {
Err(out)
}
fn run_individual_expression_test(path: &str, source: &str) -> Result<Expression, String> {
let tokenizer = tokenizer::tokenize(path, source.into()).map_err(|x| strip_path_syntax_error(x.into()))?;
if tokenizer
.iter()
.all(|x| matches!(x.token, Token::CommentLine(_) | Token::CommentBlock(_)))
{
return Ok(Expression::Value(ValueExpression::Implicit("".into(), Span::default())));
struct ParseExpressionNamespace;
impl Namespace for ParseExpressionNamespace {
fn parse_type(&self) -> ParseType {
ParseType::Line
}
let mut tokens = ParserContext::new(tokenizer);
let parsed = tokens.parse_expression().map_err(strip_path_syntax_error)?;
not_fully_consumed(&mut tokens)?;
Ok(parsed)
}
fn run_individual_statement_test(path: &str, source: &str) -> Result<Statement, String> {
let tokenizer = tokenizer::tokenize(path, source.into()).map_err(|x| strip_path_syntax_error(x.into()))?;
if tokenizer
.iter()
.all(|x| matches!(x.token, Token::CommentLine(_) | Token::CommentBlock(_)))
{
return Ok(Statement::Expression(ExpressionStatement {
expression: Expression::Value(ValueExpression::Implicit("".into(), Span::default())),
span: Span::default(),
}));
}
let mut tokens = ParserContext::new(tokenizer);
let parsed = tokens.parse_statement().map_err(strip_path_syntax_error)?;
not_fully_consumed(&mut tokens)?;
Ok(parsed)
}
fn strip_path_syntax_error(mut err: SyntaxError) -> String {
let inner = match &mut err {
SyntaxError::DeprecatedError(DeprecatedError::Error(x)) => x,
SyntaxError::Error(x) => x,
SyntaxError::TokenError(TokenError::Error(x)) => x,
};
inner.path = Arc::new("test".to_string());
err.to_string()
}
fn run_individual_parse_test(path: &str, source: &str) -> Result<Program, String> {
let tokenizer = tokenizer::tokenize(path, source.into()).map_err(|x| strip_path_syntax_error(x.into()))?;
let mut tokens = ParserContext::new(tokenizer);
let parsed = tokens.parse_program().map_err(strip_path_syntax_error)?;
not_fully_consumed(&mut tokens)?;
Ok(parsed)
}
fn emit_errors<T: PartialEq + ToString + serde::de::DeserializeOwned>(
output: Result<&T, &str>,
mode: &TestExpectationMode,
expected_output: Option<Value>,
test_index: usize,
) -> Option<TestError> {
match (output, mode) {
(Ok(output), TestExpectationMode::Pass) => {
let expected_output: Option<T> =
expected_output.map(|x| serde_yaml::from_value(x).expect("test expectation deserialize failed"));
// passed and should have
if let Some(expected_output) = expected_output.as_ref() {
if output != expected_output {
// invalid output
return Some(TestError::UnexpectedOutput {
index: test_index,
expected: expected_output.to_string(),
output: output.to_string(),
});
}
}
None
}
(Ok(_tokens), TestExpectationMode::Fail) => Some(TestError::PassedAndShouldntHave { index: test_index }),
(Err(err), TestExpectationMode::Pass) => Some(TestError::FailedAndShouldntHave {
error: err.to_string(),
index: test_index,
}),
(Err(err), TestExpectationMode::Fail) => {
let expected_output: Option<String> =
expected_output.map(|x| serde_yaml::from_value(x).expect("test expectation deserialize failed"));
if let Some(expected_output) = expected_output.as_deref() {
if err != expected_output {
// invalid output
return Some(TestError::UnexpectedError {
expected: expected_output.to_string(),
output: err.to_string(),
index: test_index,
});
}
}
None
fn run_test(&self, test: &str) -> Result<Value, String> {
let tokenizer = tokenizer::tokenize("test", test.into()).map_err(|x| x.to_string())?;
if tokenizer
.iter()
.all(|x| matches!(x.token, Token::CommentLine(_) | Token::CommentBlock(_)))
{
return Ok(serde_yaml::to_value(&Expression::Value(ValueExpression::Implicit(
"".into(),
Span::default(),
)))
.expect("serialization failed"));
}
let mut tokens = ParserContext::new(tokenizer);
let parsed = tokens.parse_expression().map_err(|x| x.to_string())?;
not_fully_consumed(&mut tokens)?;
Ok(serde_yaml::to_value(&parsed).expect("serialization failed"))
}
}
fn run_test(
config: &TestConfig,
path: &str,
source: &str,
expectations: Option<&TestExpectation>,
errors: &mut Vec<TestError>,
) -> Vec<Value> {
let end_of_header = source.find("*/").expect("failed to find header block in test");
let source = &source[end_of_header + 2..];
let mut outputs = vec![];
match &config.namespace {
TestNamespace::Token => {
let tests = split_tests_oneline(source);
if let Some(expectations) = expectations.as_ref() {
if tests.len() != expectations.outputs.len() {
errors.push(TestError::MismatchedTestExpectationLength);
}
}
let mut expected_output = expectations.as_ref().map(|x| x.outputs.iter());
for (i, test) in tests.into_iter().enumerate() {
let expected_output = expected_output
.as_mut()
.map(|x| x.next())
.flatten()
.map(|x| x.as_str())
.flatten();
let output = run_individual_token_test(path, test);
if let Some(error) = emit_errors(
output.as_ref().map_err(|x| &**x),
&config.expectation,
expected_output.map(|x| Value::String(x.to_string())),
i,
) {
errors.push(error);
} else {
outputs.push(serde_yaml::to_value(output.unwrap_or_else(|e| e)).expect("serialization failed"));
}
}
}
TestNamespace::Parse => {
if let Some(expectations) = expectations.as_ref() {
if expectations.outputs.len() != 1 {
errors.push(TestError::MismatchedTestExpectationLength);
}
}
let expected_output = expectations
.map(|x| x.outputs.get(0))
.flatten()
.map(|x| serde_yaml::from_value(x.clone()).expect("invalid test expectation form"));
let output = run_individual_parse_test(path, source);
if let Some(error) = emit_errors(
output.as_ref().map_err(|x| &**x),
&config.expectation,
expected_output,
0,
) {
errors.push(error);
} else {
outputs.push(
output
.map(|x| serde_yaml::to_value(x).expect("serialization failed"))
.unwrap_or_else(|e| serde_yaml::to_value(e).expect("serialization failed")),
);
}
}
TestNamespace::ParseStatement => {
let tests = split_tests_twoline(source);
if let Some(expectations) = expectations.as_ref() {
if tests.len() != expectations.outputs.len() {
errors.push(TestError::MismatchedTestExpectationLength);
}
}
let mut expected_output = expectations.as_ref().map(|x| x.outputs.iter());
for (i, test) in tests.into_iter().enumerate() {
let expected_output = expected_output
.as_mut()
.map(|x| x.next())
.flatten()
.map(|x| serde_yaml::from_value(x.clone()).expect("invalid test expectation form"));
struct ParseStatementNamespace;
let output = run_individual_statement_test(path, &test);
if let Some(error) = emit_errors(
output.as_ref().map_err(|x| &**x),
&config.expectation,
expected_output,
i,
) {
errors.push(error);
} else {
outputs.push(
output
.map(|x| serde_yaml::to_value(x).expect("serialization failed"))
.unwrap_or_else(|e| serde_yaml::to_value(e).expect("serialization failed")),
);
}
}
}
TestNamespace::ParseExpression => {
let tests = split_tests_oneline(source);
if let Some(expectations) = expectations.as_ref() {
if tests.len() != expectations.outputs.len() {
errors.push(TestError::MismatchedTestExpectationLength);
}
}
let mut expected_output = expectations.as_ref().map(|x| x.outputs.iter());
for (i, test) in tests.into_iter().enumerate() {
let expected_output = expected_output
.as_mut()
.map(|x| x.next())
.flatten()
.map(|x| serde_yaml::from_value(x.clone()).expect("invalid test expectation form"));
let output = run_individual_expression_test(path, test);
if let Some(error) = emit_errors(
output.as_ref().map_err(|x| &**x),
&config.expectation,
expected_output,
i,
) {
errors.push(error);
} else {
outputs.push(
output
.map(|x| serde_yaml::to_value(x).expect("serialization failed"))
.unwrap_or_else(|e| serde_yaml::to_value(e).expect("serialization failed")),
);
}
}
}
impl Namespace for ParseStatementNamespace {
fn parse_type(&self) -> ParseType {
ParseType::ContinuousLines
}
fn run_test(&self, test: &str) -> Result<Value, String> {
let tokenizer = tokenizer::tokenize("test", test.into()).map_err(|x| x.to_string())?;
if tokenizer
.iter()
.all(|x| matches!(x.token, Token::CommentLine(_) | Token::CommentBlock(_)))
{
return Ok(serde_yaml::to_value(&Statement::Expression(ExpressionStatement {
expression: Expression::Value(ValueExpression::Implicit("".into(), Span::default())),
span: Span::default(),
}))
.expect("serialization failed"));
}
let mut tokens = ParserContext::new(tokenizer);
let parsed = tokens.parse_statement().map_err(|x| x.to_string())?;
not_fully_consumed(&mut tokens)?;
Ok(serde_yaml::to_value(&parsed).expect("serialization failed"))
}
}
struct ParseNamespace;
impl Namespace for ParseNamespace {
fn parse_type(&self) -> ParseType {
ParseType::Whole
}
fn run_test(&self, test: &str) -> Result<Value, String> {
let tokenizer = tokenizer::tokenize("test", test.into()).map_err(|x| x.to_string())?;
let mut tokens = ParserContext::new(tokenizer);
let parsed = tokens.parse_program().map_err(|x| x.to_string())?;
not_fully_consumed(&mut tokens)?;
Ok(serde_yaml::to_value(&parsed).expect("serialization failed"))
}
}
struct TestRunner;
impl Runner for TestRunner {
fn resolve_namespace(&self, name: &str) -> Option<Box<dyn Namespace>> {
Some(match name {
"Parse" => Box::new(ParseNamespace),
"ParseStatement" => Box::new(ParseStatementNamespace),
"ParseExpression" => Box::new(ParseExpressionNamespace),
"Token" => Box::new(TokenNamespace),
_ => return None,
})
}
outputs
}
#[test]
pub fn parser_tests() {
let mut pass = 0;
let mut fail = Vec::new();
let mut tests = Vec::new();
let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
test_dir.push("../tests/parser/");
find_tests(&test_dir, &mut tests);
let mut outputs = vec![];
for (path, content) in tests.into_iter() {
let config = extract_test_config(&content);
if config.is_none() {
panic!("missing configuration for {}", path);
}
let config = config.unwrap();
let mut expectation_path = path.clone();
expectation_path += ".out";
let expectations: Option<TestExpectation> = if std::path::Path::new(&expectation_path).exists() {
if !std::env::var("CLEAR_LEO_TEST_EXPECTATIONS")
.unwrap_or_default()
.trim()
.is_empty()
{
None
} else {
let raw = std::fs::read_to_string(&expectation_path).expect("failed to read expectations file");
Some(serde_yaml::from_str(&raw).expect("invalid yaml in expectations file"))
}
} else {
None
};
let mut errors = vec![];
let raw_path = Path::new(&path);
let new_outputs = run_test(
&config,
raw_path.file_name().unwrap_or_default().to_str().unwrap_or_default(),
&content,
expectations.as_ref(),
&mut errors,
);
if errors.is_empty() {
if expectations.is_none() {
outputs.push((expectation_path, TestExpectation {
namespace: config.namespace,
expectation: config.expectation,
outputs: new_outputs,
}));
}
pass += 1;
} else {
fail.push(TestFailure {
path: path.clone(),
errors,
})
}
}
if !fail.is_empty() {
for (i, fail) in fail.iter().enumerate() {
println!(
"\n\n-----------------TEST #{} FAILED (and shouldn't have)-----------------",
i + 1
);
println!("File: {}", fail.path);
for error in &fail.errors {
println!("{}", error);
}
}
panic!("failed {}/{} tests", fail.len(), fail.len() + pass);
} else {
for (path, new_expectation) in outputs {
std::fs::write(
&path,
serde_yaml::to_string(&new_expectation).expect("failed to serialize expectation yaml"),
)
.expect("failed to write expectation file");
}
println!("passed {}/{} tests", pass, pass);
}
}
#[test]
pub fn parser_pass_tests() {
let mut pass = 0;
let mut fail = Vec::new();
let mut tests = Vec::new();
let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
test_dir.push("../tests/old/pass/");
find_tests(&test_dir, &mut tests);
for (path, content) in tests.into_iter() {
match crate::parse(&path, &content) {
Ok(_) => {
pass += 1;
}
Err(e) => {
fail.push(TestFailure {
path,
errors: vec![TestError::FailedAndShouldntHave {
index: 0,
error: e.to_string(),
}],
});
}
}
}
if !fail.is_empty() {
for (i, fail) in fail.iter().enumerate() {
println!(
"\n\n-----------------TEST #{} FAILED (and shouldn't have)-----------------",
i + 1
);
println!("File: {}", fail.path);
for error in &fail.errors {
println!("{}", error);
}
}
panic!("failed {}/{} tests", fail.len(), fail.len() + pass);
} else {
println!("passed {}/{} tests", pass, pass);
}
}
#[test]
pub fn parser_fail_tests() {
let mut pass = 0;
let mut fail = Vec::new();
let mut tests = Vec::new();
let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
test_dir.push("../tests/old/fail/");
find_tests(&test_dir, &mut tests);
for (path, content) in tests.into_iter() {
match crate::parse(&path, &content) {
Ok(_) => {
fail.push(path);
}
Err(_e) => {
pass += 1;
}
}
}
if !fail.is_empty() {
for (i, fail) in fail.iter().enumerate() {
println!(
"\n\n-----------------TEST #{} PASSED (and shouldn't have)-----------------",
i + 1
);
println!("File: {}", fail);
}
panic!("failed {}/{} tests", fail.len(), fail.len() + pass);
} else {
println!("passed {}/{} tests", pass, pass);
}
leo_test_framework::run_tests(&TestRunner, "parser");
}

28
test-framework/Cargo.toml Normal file
View File

@ -0,0 +1,28 @@
[package]
name = "leo-test-framework"
version = "1.4.0"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "Leo testing framework"
homepage = "https://aleo.org"
repository = "https://github.com/AleoHQ/leo"
keywords = [
"aleo",
"cryptography",
"leo",
"programming-language",
"zero-knowledge"
]
categories = [ "cryptography::cryptocurrencies", "web-programming" ]
include = [ "Cargo.toml", "src", "README.md", "LICENSE.md" ]
license = "GPL-3.0"
edition = "2018"
[dependencies.serde]
version = "1.0"
features = [ "derive" ]
[dependencies.serde_json]
version = "1.0"
[dependencies.serde_yaml]
version = "0.8"

124
test-framework/src/error.rs Normal file
View File

@ -0,0 +1,124 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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 std::fmt;
use serde_yaml::Value;
use crate::test::TestExpectationMode;
pub struct TestFailure {
pub path: String,
pub errors: Vec<TestError>,
}
#[derive(Debug)]
pub enum TestError {
UnexpectedOutput {
index: usize,
expected: Value,
output: Value,
},
PassedAndShouldntHave {
index: usize,
},
FailedAndShouldntHave {
index: usize,
error: String,
},
UnexpectedError {
index: usize,
expected: String,
output: String,
},
MismatchedTestExpectationLength,
}
impl fmt::Display for TestError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
TestError::UnexpectedOutput {
index,
expected,
output,
} => {
write!(
f,
"test #{} expected\n{}\ngot\n{}",
index + 1,
serde_yaml::to_string(&expected).expect("serialization failed"),
serde_yaml::to_string(&output).expect("serialization failed")
)
}
TestError::PassedAndShouldntHave { index } => write!(f, "test #{} passed and shouldn't have", index + 1),
TestError::FailedAndShouldntHave { index, error } => {
write!(f, "test #{} failed and shouldn't have:\n{}", index + 1, error)
}
TestError::UnexpectedError {
expected,
output,
index,
} => {
write!(f, "test #{} expected error\n{}\ngot\n{}", index + 1, expected, output)
}
TestError::MismatchedTestExpectationLength => write!(f, "invalid number of test expectations"),
}
}
}
pub fn emit_errors(
output: Result<&Value, &str>,
mode: &TestExpectationMode,
expected_output: Option<Value>,
test_index: usize,
) -> Option<TestError> {
match (output, mode) {
(Ok(output), TestExpectationMode::Pass) => {
// passed and should have
if let Some(expected_output) = expected_output.as_ref() {
if output != expected_output {
// invalid output
return Some(TestError::UnexpectedOutput {
index: test_index,
expected: expected_output.clone(),
output: output.clone(),
});
}
}
None
}
(Ok(_tokens), TestExpectationMode::Fail) => Some(TestError::PassedAndShouldntHave { index: test_index }),
(Err(err), TestExpectationMode::Pass) => Some(TestError::FailedAndShouldntHave {
error: err.to_string(),
index: test_index,
}),
(Err(err), TestExpectationMode::Fail) => {
let expected_output: Option<String> =
expected_output.map(|x| serde_yaml::from_value(x).expect("test expectation deserialize failed"));
if let Some(expected_output) = expected_output.as_deref() {
if err != expected_output {
// invalid output
return Some(TestError::UnexpectedError {
expected: expected_output.to_string(),
output: err.to_string(),
index: test_index,
});
}
}
None
}
}
}

56
test-framework/src/fetch.rs Normal file
View File

@ -0,0 +1,56 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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 std::{fs, path::Path};
pub fn find_tests<T: AsRef<Path>>(path: T, out: &mut Vec<(String, String)>) {
for entry in fs::read_dir(path).expect("fail to read tests").into_iter() {
let entry = entry.expect("fail to read tests").path();
if entry.is_dir() {
find_tests(entry.as_path(), out);
continue;
} else if entry.extension().map(|x| x.to_str()).flatten().unwrap_or_default() != "leo" {
continue;
}
let content = fs::read_to_string(entry.as_path()).expect("failed to read test");
out.push((entry.as_path().to_str().unwrap_or_default().to_string(), content));
}
}
pub fn split_tests_oneline(source: &str) -> Vec<&str> {
source.lines().map(|x| x.trim()).filter(|x| !x.is_empty()).collect()
}
pub fn split_tests_twoline(source: &str) -> Vec<String> {
let mut out = vec![];
let mut lines = vec![];
for line in source.lines() {
let line = line.trim();
if line.is_empty() {
if !lines.is_empty() {
out.push(lines.join("\n"));
}
lines.clear();
continue;
}
lines.push(line);
}
let last_test = lines.join("\n");
if !last_test.trim().is_empty() {
out.push(last_test.trim().to_string());
}
out
}

35
test-framework/src/lib.rs Normal file
View File

@ -0,0 +1,35 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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/>.
//! The test framework to run integration tests with Leo code text.
//!
//! This module contains the [`run_tests()`] method which runs all integration tests in the
//! root [`tests/`] directory.
//!
//! To regenerate the tests after a syntax change or failing test, delete the [`tests/expectations/`]
//! directory and run the [`parser_tests()`] test in [`parser/src/test.rs`].
pub mod error;
pub mod fetch;
pub mod output;
pub mod runner;
pub mod test;
pub use runner::*;

25
test-framework/src/output.rs Normal file
View File

@ -0,0 +1,25 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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::test::TestExpectationMode;
use serde_yaml::Value;
#[derive(serde::Serialize, serde::Deserialize, Clone)]
pub struct TestExpectation {
pub namespace: String,
pub expectation: TestExpectationMode,
pub outputs: Vec<Value>,
}

196
test-framework/src/runner.rs Normal file
View File

@ -0,0 +1,196 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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 serde_yaml::Value;
use std::path::{Path, PathBuf};
use crate::{error::*, fetch::find_tests, output::TestExpectation, test::*};
#[derive(Debug, PartialEq, Clone, Copy)]
pub enum ParseType {
Line,
ContinuousLines,
Whole,
}
pub trait Namespace {
fn parse_type(&self) -> ParseType;
fn run_test(&self, test: &str) -> Result<Value, String>;
}
pub trait Runner {
fn resolve_namespace(&self, name: &str) -> Option<Box<dyn Namespace>>;
}
pub fn run_tests<T: Runner>(runner: &T, expectation_category: &str) {
let mut pass_categories = 0;
let mut pass_tests = 0;
let mut fail_tests = 0;
let mut fail_categories = Vec::new();
let mut tests = Vec::new();
let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
test_dir.push("../tests/");
let mut expectation_dir = test_dir.clone();
expectation_dir.push("expectations");
find_tests(&test_dir, &mut tests);
let mut outputs = vec![];
for (path, content) in tests.into_iter() {
let config = extract_test_config(&content);
if config.is_none() {
panic!("missing configuration for {}", path);
}
let config = config.unwrap();
let namespace = runner.resolve_namespace(&config.namespace);
if namespace.is_none() {
continue;
}
let namespace = namespace.unwrap();
let path = Path::new(&path);
let relative_path = path.strip_prefix(&test_dir).expect("path error for test");
let mut expectation_path = expectation_dir.clone();
expectation_path.push(expectation_category);
expectation_path.push(relative_path.parent().expect("no parent dir for test"));
let mut test_name = relative_path
.file_name()
.expect("no file name for test")
.to_str()
.unwrap()
.to_string();
test_name += ".out";
expectation_path.push(&test_name);
let expectations: Option<TestExpectation> = if expectation_path.exists() {
if !std::env::var("CLEAR_LEO_TEST_EXPECTATIONS")
.unwrap_or_default()
.trim()
.is_empty()
{
None
} else {
let raw = std::fs::read_to_string(&expectation_path).expect("failed to read expectations file");
Some(serde_yaml::from_str(&raw).expect("invalid yaml in expectations file"))
}
} else {
None
};
let end_of_header = content.find("*/").expect("failed to find header block in test");
let content = &content[end_of_header + 2..];
let tests = match namespace.parse_type() {
ParseType::Line => crate::fetch::split_tests_oneline(content)
.into_iter()
.map(|x| x.to_string())
.collect(),
ParseType::ContinuousLines => crate::fetch::split_tests_twoline(content),
ParseType::Whole => vec![content.to_string()],
};
let mut errors = vec![];
if let Some(expectations) = expectations.as_ref() {
if tests.len() != expectations.outputs.len() {
errors.push(TestError::MismatchedTestExpectationLength);
}
}
let mut new_outputs = vec![];
let mut expected_output = expectations.as_ref().map(|x| x.outputs.iter());
for (i, test) in tests.into_iter().enumerate() {
let expected_output = expected_output
.as_mut()
.map(|x| x.next())
.flatten()
.map(|x| x.as_str())
.flatten();
let output = namespace.run_test(&test);
if let Some(error) = emit_errors(
output.as_ref().map_err(|x| &**x),
&config.expectation,
expected_output.map(|x| Value::String(x.to_string())),
i,
) {
fail_tests += 1;
errors.push(error);
} else {
pass_tests += 1;
new_outputs.push(
output
.as_ref()
.map(|x| serde_yaml::to_value(x).expect("serialization failed"))
.unwrap_or_else(|e| Value::String(e.clone())),
);
}
}
if errors.is_empty() {
if expectations.is_none() {
outputs.push((expectation_path, TestExpectation {
namespace: config.namespace,
expectation: config.expectation,
outputs: new_outputs,
}));
}
pass_categories += 1;
} else {
fail_categories.push(TestFailure {
path: path.to_str().unwrap().to_string(),
errors,
})
}
}
if !fail_categories.is_empty() {
for (i, fail) in fail_categories.iter().enumerate() {
println!(
"\n\n-----------------TEST #{} FAILED (and shouldn't have)-----------------",
i + 1
);
println!("File: {}", fail.path);
for error in &fail.errors {
println!("{}", error);
}
}
panic!(
"failed {}/{} tests in {}/{} categories",
pass_tests,
fail_tests + pass_tests,
fail_categories.len(),
fail_categories.len() + pass_categories
);
} else {
for (path, new_expectation) in outputs {
std::fs::create_dir_all(path.parent().unwrap()).expect("failed to make test expectation parent directory");
std::fs::write(
&path,
serde_yaml::to_string(&new_expectation).expect("failed to serialize expectation yaml"),
)
.expect("failed to write expectation file");
}
println!(
"passed {}/{} tests in {}/{} categories",
pass_tests,
fail_tests + pass_tests,
pass_categories,
pass_categories
);
}
}

34
test-framework/src/test.rs Normal file
View File

@ -0,0 +1,34 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 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/>.
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug, Clone)]
pub enum TestExpectationMode {
Pass,
Fail,
}
#[derive(serde::Serialize, serde::Deserialize)]
pub struct TestConfig {
pub namespace: String,
pub expectation: TestExpectationMode,
}
pub fn extract_test_config(source: &str) -> Option<TestConfig> {
let first_comment_start = source.find("/*")?;
let end_first_comment = source[first_comment_start + 2..].find("*/")?;
let comment_inner = &source[first_comment_start + 2..first_comment_start + 2 + end_first_comment];
Some(serde_yaml::from_str(comment_inner).expect("invalid test configuration"))
}

16
tests/parser/circuits/big_self.leo.out → tests/expectations/parser/parser/circuits/big_self.leo.out
View File

@ -6,12 +6,12 @@ outputs:
expected_input: []
imports: []
circuits:
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"big_self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"big_self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
members:
- CircuitFunction:
annotations: []
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"big_self.leo\\\",\\\"content\\\":\\\" function x() -> Self {\\\"}\"}"
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function x() -> Self {\\\"}\"}"
input: []
output: SelfType
block:
@ -19,34 +19,34 @@ outputs:
- Return:
expression:
CircuitInit:
name: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"big_self.leo\\\",\\\"content\\\":\\\" return Self {};\\\"}\"}"
name: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" return Self {};\\\"}\"}"
members: []
span:
line_start: 5
line_stop: 5
col_start: 16
col_stop: 23
path: big_self.leo
path: test
content: " return Self {};"
span:
line_start: 5
line_stop: 5
col_start: 9
col_stop: 23
path: big_self.leo
path: test
content: " return Self {};"
span:
line_start: 4
line_stop: 6
col_start: 26
col_stop: 6
path: big_self.leo
path: test
content: " function x() -> Self {\n...\n }"
span:
line_start: 4
line_stop: 6
col_start: 5
col_stop: 6
path: big_self.leo
path: test
content: " function x() -> Self {\n...\n }"
functions: {}

4
tests/parser/circuits/empty.leo.out → tests/expectations/parser/parser/circuits/empty.leo.out
View File

@ -6,7 +6,7 @@ outputs:
expected_input: []
imports: []
circuits:
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"empty.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"empty.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
members: []
functions: {}

28
tests/parser/circuits/field_and_functions.leo.out → tests/expectations/parser/parser/circuits/field_and_functions.leo.out
View File

@ -6,18 +6,18 @@ outputs:
expected_input: []
imports: []
circuits:
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
members:
- CircuitVariable:
- "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\" x: u32,\\\"}\"}"
- "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" x: u32,\\\"}\"}"
- IntegerType: U32
- CircuitVariable:
- "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\" y: u32,\\\"}\"}"
- "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" y: u32,\\\"}\"}"
- IntegerType: U32
- CircuitFunction:
annotations: []
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\" function x() {\\\"}\"}"
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function x() {\\\"}\"}"
input: []
output: ~
block:
@ -31,32 +31,32 @@ outputs:
line_stop: 7
col_start: 16
col_stop: 18
path: field_and_functions.leo
path: test
content: " return ();"
span:
line_start: 7
line_stop: 7
col_start: 9
col_stop: 18
path: field_and_functions.leo
path: test
content: " return ();"
span:
line_start: 6
line_stop: 8
col_start: 18
col_stop: 6
path: field_and_functions.leo
path: test
content: " function x() {\n...\n }"
span:
line_start: 6
line_stop: 8
col_start: 5
col_stop: 6
path: field_and_functions.leo
path: test
content: " function x() {\n...\n }"
- CircuitFunction:
annotations: []
identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\" function y() {\\\"}\"}"
identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function y() {\\\"}\"}"
input: []
output: ~
block:
@ -70,27 +70,27 @@ outputs:
line_stop: 10
col_start: 16
col_stop: 18
path: field_and_functions.leo
path: test
content: " return ();"
span:
line_start: 10
line_stop: 10
col_start: 9
col_stop: 18
path: field_and_functions.leo
path: test
content: " return ();"
span:
line_start: 9
line_stop: 11
col_start: 18
col_stop: 6
path: field_and_functions.leo
path: test
content: " function y() {\n...\n }"
span:
line_start: 9
line_stop: 11
col_start: 5
col_stop: 6
path: field_and_functions.leo
path: test
content: " function y() {\n...\n }"
functions: {}

8
tests/parser/circuits/fields.leo.out → tests/expectations/parser/parser/circuits/fields.leo.out
View File

@ -6,13 +6,13 @@ outputs:
expected_input: []
imports: []
circuits:
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"fields.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"fields.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
members:
- CircuitVariable:
- "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"fields.leo\\\",\\\"content\\\":\\\" x: u32,\\\"}\"}"
- "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" x: u32,\\\"}\"}"
- IntegerType: U32
- CircuitVariable:
- "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"fields.leo\\\",\\\"content\\\":\\\" y: u32,\\\"}\"}"
- "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" y: u32,\\\"}\"}"
- IntegerType: U32
functions: {}

24
tests/parser/circuits/functions.leo.out → tests/expectations/parser/parser/circuits/functions.leo.out
View File

@ -6,12 +6,12 @@ outputs:
expected_input: []
imports: []
circuits:
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"functions.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"functions.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
members:
- CircuitFunction:
annotations: []
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"functions.leo\\\",\\\"content\\\":\\\" function x() {\\\"}\"}"
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function x() {\\\"}\"}"
input: []
output: ~
block:
@ -25,32 +25,32 @@ outputs:
line_stop: 5
col_start: 16
col_stop: 18
path: functions.leo
path: test
content: " return ();"
span:
line_start: 5
line_stop: 5
col_start: 9
col_stop: 18
path: functions.leo
path: test
content: " return ();"
span:
line_start: 4
line_stop: 6
col_start: 18
col_stop: 6
path: functions.leo
path: test
content: " function x() {\n...\n }"
span:
line_start: 4
line_stop: 6
col_start: 5
col_stop: 6
path: functions.leo
path: test
content: " function x() {\n...\n }"
- CircuitFunction:
annotations: []
identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":7,\\\"line_stop\\\":7,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"functions.leo\\\",\\\"content\\\":\\\" function y() {\\\"}\"}"
identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":7,\\\"line_stop\\\":7,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function y() {\\\"}\"}"
input: []
output: ~
block:
@ -64,27 +64,27 @@ outputs:
line_stop: 8
col_start: 16
col_stop: 18
path: functions.leo
path: test
content: " return ();"
span:
line_start: 8
line_stop: 8
col_start: 9
col_stop: 18
path: functions.leo
path: test
content: " return ();"
span:
line_start: 7
line_stop: 9
col_start: 18
col_stop: 6
path: functions.leo
path: test
content: " function y() {\n...\n }"
span:
line_start: 7
line_stop: 9
col_start: 5
col_stop: 6
path: functions.leo
path: test
content: " function y() {\n...\n }"
functions: {}

16
tests/parser/circuits/mut_self.leo.out → tests/expectations/parser/parser/circuits/mut_self.leo.out
View File

@ -6,14 +6,14 @@ outputs:
expected_input: []
imports: []
circuits:
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"mut_self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"mut_self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
members:
- CircuitFunction:
annotations: []
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"mut_self.leo\\\",\\\"content\\\":\\\" function x(mut self) {\\\"}\"}"
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function x(mut self) {\\\"}\"}"
input:
- MutSelfKeyword: "{\"name\":\"mut self\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":16,\\\"col_stop\\\":24,\\\"path\\\":\\\"mut_self.leo\\\",\\\"content\\\":\\\" function x(mut self) {\\\"}\"}"
- MutSelfKeyword: "{\"name\":\"mut self\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":16,\\\"col_stop\\\":24,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function x(mut self) {\\\"}\"}"
output: ~
block:
statements:
@ -26,27 +26,27 @@ outputs:
line_stop: 5
col_start: 16
col_stop: 18
path: mut_self.leo
path: test
content: " return ();"
span:
line_start: 5
line_stop: 5
col_start: 9
col_stop: 18
path: mut_self.leo
path: test
content: " return ();"
span:
line_start: 4
line_stop: 6
col_start: 26
col_stop: 6
path: mut_self.leo
path: test
content: " function x(mut self) {\n...\n }"
span:
line_start: 4
line_stop: 6
col_start: 5
col_stop: 6
path: mut_self.leo
path: test
content: " function x(mut self) {\n...\n }"
functions: {}

16
tests/parser/circuits/self.leo.out → tests/expectations/parser/parser/circuits/self.leo.out
View File

@ -6,14 +6,14 @@ outputs:
expected_input: []
imports: []
circuits:
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
"{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
members:
- CircuitFunction:
annotations: []
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"self.leo\\\",\\\"content\\\":\\\" function x(self) {\\\"}\"}"
identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function x(self) {\\\"}\"}"
input:
- SelfKeyword: "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"self.leo\\\",\\\"content\\\":\\\" function x(self) {\\\"}\"}"
- SelfKeyword: "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\" function x(self) {\\\"}\"}"
output: ~
block:
statements:
@ -26,27 +26,27 @@ outputs:
line_stop: 5
col_start: 16
col_stop: 18
path: self.leo
path: test
content: " return ();"
span:
line_start: 5
line_stop: 5
col_start: 9
col_stop: 18
path: self.leo
path: test
content: " return ();"
span:
line_start: 4
line_stop: 6
col_start: 22
col_stop: 6
path: self.leo
path: test
content: " function x(self) {\n...\n }"
span:
line_start: 4
line_stop: 6
col_start: 5
col_stop: 6
path: self.leo
path: test
content: " function x(self) {\n...\n }"
functions: {}

84
tests/parser/expression/access/array_access.leo.out → tests/expectations/parser/parser/expression/access/array_access.leo.out
View File

@ -4,7 +4,7 @@ expectation: Pass
outputs:
- ArrayAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[0]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0]\\\"}\"}"
index:
Value:
Implicit:
@ -13,18 +13,18 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: array_access.leo
path: test
content: "x[0]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: array_access.leo
path: test
content: "x[0]"
- ArrayAccess:
array:
Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"X[1]\\\"}\"}"
Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X[1]\\\"}\"}"
index:
Value:
Implicit:
@ -33,18 +33,18 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: array_access.leo
path: test
content: "X[1]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: array_access.leo
path: test
content: "X[1]"
- ArrayAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[0u8]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0u8]\\\"}\"}"
index:
Value:
Integer:
@ -54,20 +54,20 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 6
path: array_access.leo
path: test
content: "x[0u8]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 7
path: array_access.leo
path: test
content: "x[0u8]"
- ArrayAccess:
array:
ArrayAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[1u8][2u8]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[1u8][2u8]\\\"}\"}"
index:
Value:
Integer:
@ -77,14 +77,14 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 6
path: array_access.leo
path: test
content: "x[1u8][2u8]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 7
path: array_access.leo
path: test
content: "x[1u8][2u8]"
index:
Value:
@ -95,14 +95,14 @@ outputs:
line_stop: 1
col_start: 8
col_stop: 11
path: array_access.leo
path: test
content: "x[1u8][2u8]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 12
path: array_access.leo
path: test
content: "x[1u8][2u8]"
- ArrayAccess:
array:
@ -110,39 +110,39 @@ outputs:
array:
ArrayAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
index:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: array_access.leo
path: test
content: "x[x][y][z]"
index:
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: array_access.leo
path: test
content: "x[x][y][z]"
index:
Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 11
path: array_access.leo
path: test
content: "x[x][y][z]"
- Call:
function:
ArrayAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[0]()\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0]()\\\"}\"}"
index:
Value:
Implicit:
@ -151,14 +151,14 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: array_access.leo
path: test
content: "x[0]()"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: array_access.leo
path: test
content: "x[0]()"
arguments: []
span:
@ -166,20 +166,20 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: array_access.leo
path: test
content: "x[0]()"
- ArrayAccess:
array:
Call:
function:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x()[0]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x()[0]\\\"}\"}"
arguments: []
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: array_access.leo
path: test
content: "x()[0]"
index:
Value:
@ -189,14 +189,14 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: array_access.leo
path: test
content: "x()[0]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 7
path: array_access.leo
path: test
content: "x()[0]"
- Call:
function:
@ -204,32 +204,32 @@ outputs:
circuit:
Call:
function:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
arguments:
- Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
- Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: array_access.leo
path: test
content: "x(y)::y(x)"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: array_access.leo
path: test
content: "x(y)::y(x)"
arguments:
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 11
path: array_access.leo
path: test
content: "x(y)::y(x)"
- ArrayAccess:
array:
@ -237,15 +237,15 @@ outputs:
tuple:
ArrayAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
index:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: array_access.leo
path: test
content: "x[x].0[x]"
index:
value: "0"
@ -254,14 +254,14 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: array_access.leo
path: test
content: "x[x].0[x]"
index:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 10
path: array_access.leo
path: test
content: "x[x].0[x]"

130
tests/parser/expression/access/array_range_access.leo.out → tests/expectations/parser/parser/expression/access/array_range_access.leo.out
View File

@ -4,7 +4,7 @@ expectation: Pass
outputs:
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..]\\\"}\"}"
left: ~
right: ~
span:
@ -12,11 +12,11 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: array_range_access.leo
path: test
content: "x[..]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[1..]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[1..]\\\"}\"}"
left:
Value:
Implicit:
@ -25,7 +25,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: array_range_access.leo
path: test
content: "x[1..]"
right: ~
span:
@ -33,11 +33,11 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: array_range_access.leo
path: test
content: "x[1..]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..1]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..1]\\\"}\"}"
left: ~
right:
Value:
@ -47,18 +47,18 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: array_range_access.leo
path: test
content: "x[..1]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 7
path: array_range_access.leo
path: test
content: "x[..1]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[1..1]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[1..1]\\\"}\"}"
left:
Value:
Implicit:
@ -67,7 +67,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: array_range_access.leo
path: test
content: "x[1..1]"
right:
Value:
@ -77,18 +77,18 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: array_range_access.leo
path: test
content: "x[1..1]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: array_range_access.leo
path: test
content: "x[1..1]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[0..100]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0..100]\\\"}\"}"
left:
Value:
Implicit:
@ -97,7 +97,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: array_range_access.leo
path: test
content: "x[0..100]"
right:
Value:
@ -107,20 +107,20 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 9
path: array_range_access.leo
path: test
content: "x[0..100]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 10
path: array_range_access.leo
path: test
content: "x[0..100]"
- ArrayAccess:
array:
ArrayAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[323452345.2345234523453453][323452345.2345234523453453]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[323452345.2345234523453453][323452345.2345234523453453]\\\"}\"}"
index:
TupleAccess:
tuple:
@ -131,7 +131,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 12
path: array_range_access.leo
path: test
content: "x[323452345.2345234523453453][323452345.2345234523453453]"
index:
value: "2345234523453453"
@ -140,14 +140,14 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 29
path: array_range_access.leo
path: test
content: "x[323452345.2345234523453453][323452345.2345234523453453]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 30
path: array_range_access.leo
path: test
content: "x[323452345.2345234523453453][323452345.2345234523453453]"
index:
TupleAccess:
@ -159,7 +159,7 @@ outputs:
line_stop: 1
col_start: 31
col_stop: 40
path: array_range_access.leo
path: test
content: "x[323452345.2345234523453453][323452345.2345234523453453]"
index:
value: "2345234523453453"
@ -168,18 +168,18 @@ outputs:
line_stop: 1
col_start: 31
col_stop: 57
path: array_range_access.leo
path: test
content: "x[323452345.2345234523453453][323452345.2345234523453453]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 58
path: array_range_access.leo
path: test
content: "x[323452345.2345234523453453][323452345.2345234523453453]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[0u8..1u8]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0u8..1u8]\\\"}\"}"
left:
Value:
Integer:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 6
path: array_range_access.leo
path: test
content: "x[0u8..1u8]"
right:
Value:
@ -200,18 +200,18 @@ outputs:
line_stop: 1
col_start: 8
col_stop: 11
path: array_range_access.leo
path: test
content: "x[0u8..1u8]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 12
path: array_range_access.leo
path: test
content: "x[0u8..1u8]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[0u8..]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0u8..]\\\"}\"}"
left:
Value:
Integer:
@ -221,7 +221,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 6
path: array_range_access.leo
path: test
content: "x[0u8..]"
right: ~
span:
@ -229,11 +229,11 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 9
path: array_range_access.leo
path: test
content: "x[0u8..]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..0u8]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..0u8]\\\"}\"}"
left: ~
right:
Value:
@ -244,18 +244,18 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 8
path: array_range_access.leo
path: test
content: "x[..0u8]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 9
path: array_range_access.leo
path: test
content: "x[..0u8]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..]\\\"}\"}"
left: ~
right: ~
span:
@ -263,22 +263,22 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: array_range_access.leo
path: test
content: "x[..]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
left:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 3
col_stop: 6
path: array_range_access.leo
path: test
content: "x[x.y..]"
right: ~
span:
@ -286,116 +286,116 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 9
path: array_range_access.leo
path: test
content: "x[x.y..]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
left: ~
right:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 5
col_stop: 8
path: array_range_access.leo
path: test
content: "x[..y.x]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 9
path: array_range_access.leo
path: test
content: "x[..y.x]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
left:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 3
col_stop: 6
path: array_range_access.leo
path: test
content: "x[x.y..y.x]"
right:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 8
col_stop: 11
path: array_range_access.leo
path: test
content: "x[x.y..y.x]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 12
path: array_range_access.leo
path: test
content: "x[x.y..y.x]"
- ArrayRangeAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
left:
CircuitMemberAccess:
circuit:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 3
col_stop: 6
path: array_range_access.leo
path: test
content: "x[x.y.x..y.x.y]"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 3
col_stop: 8
path: array_range_access.leo
path: test
content: "x[x.y.x..y.x.y]"
right:
CircuitMemberAccess:
circuit:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":12,\\\"col_stop\\\":13,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":12,\\\"col_stop\\\":13,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 10
col_stop: 13
path: array_range_access.leo
path: test
content: "x[x.y.x..y.x.y]"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 10
col_stop: 15
path: array_range_access.leo
path: test
content: "x[x.y.x..y.x.y]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 16
path: array_range_access.leo
path: test
content: "x[x.y.x..y.x.y]"

68
tests/parser/expression/access/call.leo.out → tests/expectations/parser/parser/expression/access/call.leo.out
View File

@ -4,77 +4,77 @@ expectation: Pass
outputs:
- Call:
function:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x()\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x()\\\"}\"}"
arguments: []
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: call.leo
path: test
content: x()
- Call:
function:
Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"X()\\\"}\"}"
Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X()\\\"}\"}"
arguments: []
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: call.leo
path: test
content: X()
- Call:
function:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y)\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)\\\"}\"}"
arguments:
- Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y)\\\"}\"}"
- Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: call.leo
path: test
content: x(y)
- Call:
function:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
arguments:
- Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
- Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
- Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
- Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: call.leo
path: test
content: "x(y, z)"
- Call:
function:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
arguments:
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
- Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
- Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
- Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
- Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 11
path: call.leo
path: test
content: "x(x, y, z)"
- Call:
function:
CircuitStaticFunctionAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: call.leo
path: test
content: "x::y()"
arguments: []
span:
@ -82,35 +82,35 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: call.leo
path: test
content: "x::y()"
- Call:
function:
CircuitStaticFunctionAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: call.leo
path: test
content: "x::y(x)"
arguments:
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: call.leo
path: test
content: "x::y(x)"
- Call:
function:
TupleAccess:
tuple:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x.0(x)\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.0(x)\\\"}\"}"
index:
value: "0"
span:
@ -118,22 +118,22 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: call.leo
path: test
content: x.0(x)
arguments:
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x.0(x)\\\"}\"}"
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.0(x)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 7
path: call.leo
path: test
content: x.0(x)
- Call:
function:
ArrayAccess:
array:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x[0](x)\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0](x)\\\"}\"}"
index:
Value:
Implicit:
@ -142,21 +142,21 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: call.leo
path: test
content: "x[0](x)"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: call.leo
path: test
content: "x[0](x)"
arguments:
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x[0](x)\\\"}\"}"
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0](x)\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: call.leo
path: test
content: "x[0](x)"

48
tests/parser/expression/access/circuit.leo.out → tests/expectations/parser/parser/expression/access/circuit.leo.out
View File

@ -4,59 +4,59 @@ expectation: Pass
outputs:
- CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: circuit.leo
path: test
content: x.y
- CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"X.Y\\\"}\"}"
name: "{\"name\":\"Y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"X.Y\\\"}\"}"
Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X.Y\\\"}\"}"
name: "{\"name\":\"Y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X.Y\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: circuit.leo
path: test
content: X.Y
- CircuitMemberAccess:
circuit:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: circuit.leo
path: test
content: x.y.z
name: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
name: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 6
path: circuit.leo
path: test
content: x.y.z
- Call:
function:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y()\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y()\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y()\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y()\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: circuit.leo
path: test
content: x.y()
arguments: []
span:
@ -64,20 +64,20 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: circuit.leo
path: test
content: x.y()
- TupleAccess:
tuple:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.0\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.0\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.0\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.0\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: circuit.leo
path: test
content: x.y.0
index:
value: "0"
@ -86,20 +86,20 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: circuit.leo
path: test
content: x.y.0
- ArrayAccess:
array:
CircuitMemberAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y[1]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y[1]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y[1]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y[1]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: circuit.leo
path: test
content: "x.y[1]"
index:
Value:
@ -109,12 +109,12 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: circuit.leo
path: test
content: "x.y[1]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 7
path: circuit.leo
path: test
content: "x.y[1]"

48
tests/parser/expression/access/circuit_static.leo.out → tests/expectations/parser/parser/expression/access/circuit_static.leo.out
View File

@ -4,59 +4,59 @@ expectation: Pass
outputs:
- CircuitStaticFunctionAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: circuit_static.leo
path: test
content: "x::y"
- CircuitStaticFunctionAccess:
circuit:
Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"X::Y\\\"}\"}"
name: "{\"name\":\"Y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"X::Y\\\"}\"}"
Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X::Y\\\"}\"}"
name: "{\"name\":\"Y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X::Y\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: circuit_static.leo
path: test
content: "X::Y"
- CircuitStaticFunctionAccess:
circuit:
CircuitStaticFunctionAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: circuit_static.leo
path: test
content: "x::y::z"
name: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
name: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: circuit_static.leo
path: test
content: "x::y::z"
- Call:
function:
CircuitStaticFunctionAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: circuit_static.leo
path: test
content: "x::y()"
arguments: []
span:
@ -64,20 +64,20 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: circuit_static.leo
path: test
content: "x::y()"
- TupleAccess:
tuple:
CircuitStaticFunctionAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y.0\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y.0\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y.0\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y.0\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: circuit_static.leo
path: test
content: "x::y.0"
index:
value: "0"
@ -86,20 +86,20 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: circuit_static.leo
path: test
content: "x::y.0"
- ArrayAccess:
array:
CircuitStaticFunctionAccess:
circuit:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y[1]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y[1]\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y[1]\\\"}\"}"
name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y[1]\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: circuit_static.leo
path: test
content: "x::y[1]"
index:
Value:
@ -109,12 +109,12 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: circuit_static.leo
path: test
content: "x::y[1]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: circuit_static.leo
path: test
content: "x::y[1]"

30
tests/parser/expression/access/tuple.leo.out → tests/expectations/parser/parser/expression/access/tuple.leo.out
View File

@ -4,7 +4,7 @@ expectation: Pass
outputs:
- TupleAccess:
tuple:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.0\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.0\\\"}\"}"
index:
value: "0"
span:
@ -12,11 +12,11 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: tuple.leo
path: test
content: x.0
- TupleAccess:
tuple:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.1\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.1\\\"}\"}"
index:
value: "1"
span:
@ -24,11 +24,11 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: tuple.leo
path: test
content: x.1
- TupleAccess:
tuple:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.2\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.2\\\"}\"}"
index:
value: "2"
span:
@ -36,13 +36,13 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: tuple.leo
path: test
content: x.2
- TupleAccess:
tuple:
TupleAccess:
tuple:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.0.0\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.0.0\\\"}\"}"
index:
value: "0"
span:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: tuple.leo
path: test
content: x.0.0
index:
value: "0"
@ -59,13 +59,13 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: tuple.leo
path: test
content: x.0.0
- TupleAccess:
tuple:
TupleAccess:
tuple:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.1.1\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.1.1\\\"}\"}"
index:
value: "1"
span:
@ -73,7 +73,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: tuple.leo
path: test
content: x.1.1
index:
value: "1"
@ -82,13 +82,13 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: tuple.leo
path: test
content: x.1.1
- TupleAccess:
tuple:
TupleAccess:
tuple:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.2.2\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.2.2\\\"}\"}"
index:
value: "2"
span:
@ -96,7 +96,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: tuple.leo
path: test
content: x.2.2
index:
value: "2"
@ -105,5 +105,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: tuple.leo
path: test
content: x.2.2

28
tests/parser/expression/array_init.leo.out → tests/expectations/parser/parser/expression/array_init.leo.out
View File

@ -12,7 +12,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 5
path: array_init.leo
path: test
content: "[0u8; 1]"
dimensions:
- value: "1"
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 9
path: array_init.leo
path: test
content: "[0u8; 1]"
- ArrayInit:
element:
@ -32,7 +32,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 3
path: array_init.leo
path: test
content: "[0; 1]"
dimensions:
- value: "1"
@ -41,7 +41,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: array_init.leo
path: test
content: "[0; 1]"
- ArrayInit:
element:
@ -52,7 +52,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 3
path: array_init.leo
path: test
content: "[0; (1)]"
dimensions:
- value: "1"
@ -61,7 +61,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 9
path: array_init.leo
path: test
content: "[0; (1)]"
- ArrayInit:
element:
@ -72,7 +72,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 3
path: array_init.leo
path: test
content: "[0; (1, 2)]"
dimensions:
- value: "1"
@ -82,7 +82,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: array_init.leo
path: test
content: "[0; (1, 2)]"
- ArrayInit:
element:
@ -93,7 +93,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 3
path: array_init.leo
path: test
content: "[0; (1, 2, 3)]"
dimensions:
- value: "1"
@ -104,7 +104,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: array_init.leo
path: test
content: "[0; (1, 2, 3)]"
- ArrayInit:
element:
@ -119,7 +119,7 @@ outputs:
line_stop: 1
col_start: 4
col_stop: 5
path: array_init.leo
path: test
content: "[[[0; 3]; 2]; 1]"
dimensions:
- value: "3"
@ -128,7 +128,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 9
path: array_init.leo
path: test
content: "[[[0; 3]; 2]; 1]"
dimensions:
- value: "2"
@ -137,7 +137,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 13
path: array_init.leo
path: test
content: "[[[0; 3]; 2]; 1]"
dimensions:
- value: "1"
@ -146,5 +146,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 17
path: array_init.leo
path: test
content: "[[[0; 3]; 2]; 1]"

0
tests/parser/expression/array_init_fail.leo.out → tests/expectations/parser/parser/expression/array_init_fail.leo.out
View File

64
tests/parser/expression/array_inline.leo.out → tests/expectations/parser/parser/expression/array_inline.leo.out
View File

@ -13,7 +13,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 5
path: array_inline.leo
path: test
content: "[0u8, 1, 2, 3]"
- Expression:
Value:
@ -23,7 +23,7 @@ outputs:
line_stop: 1
col_start: 7
col_stop: 8
path: array_inline.leo
path: test
content: "[0u8, 1, 2, 3]"
- Expression:
Value:
@ -33,7 +33,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: array_inline.leo
path: test
content: "[0u8, 1, 2, 3]"
- Expression:
Value:
@ -43,14 +43,14 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: array_inline.leo
path: test
content: "[0u8, 1, 2, 3]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 15
path: array_inline.leo
path: test
content: "[0u8, 1, 2, 3]"
- ArrayInline:
elements:
@ -62,14 +62,14 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 3
path: array_inline.leo
path: test
content: "[1]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: array_inline.leo
path: test
content: "[1]"
- ArrayInline:
elements:
@ -82,14 +82,14 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 5
path: array_inline.leo
path: test
content: "[1u8]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 6
path: array_inline.leo
path: test
content: "[1u8]"
- ArrayInline:
elements:
@ -102,14 +102,14 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 5
path: array_inline.leo
path: test
content: "[1u8,]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 7
path: array_inline.leo
path: test
content: "[1u8,]"
- ArrayInline:
elements:
@ -121,7 +121,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 3
path: array_inline.leo
path: test
content: "[0, 1,]"
- Expression:
Value:
@ -131,14 +131,14 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: array_inline.leo
path: test
content: "[0, 1,]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: array_inline.leo
path: test
content: "[0, 1,]"
- ArrayInline:
elements:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 3
path: array_inline.leo
path: test
content: "[0,1,]"
- Expression:
Value:
@ -160,14 +160,14 @@ outputs:
line_stop: 1
col_start: 4
col_stop: 5
path: array_inline.leo
path: test
content: "[0,1,]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 7
path: array_inline.leo
path: test
content: "[0,1,]"
- ArrayInline:
elements: []
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 3
path: array_inline.leo
path: test
content: "[]"
- ArrayInline:
elements:
@ -191,7 +191,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
- Expression:
Value:
@ -201,7 +201,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
- Expression:
Value:
@ -211,14 +211,14 @@ outputs:
line_stop: 1
col_start: 7
col_stop: 8
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
span:
line_start: 1
line_stop: 1
col_start: 2
col_stop: 9
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
- Expression:
ArrayInline:
@ -231,7 +231,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
- Expression:
Value:
@ -241,7 +241,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
- Expression:
Value:
@ -251,21 +251,21 @@ outputs:
line_stop: 1
col_start: 15
col_stop: 16
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
span:
line_start: 1
line_stop: 1
col_start: 10
col_stop: 17
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 18
path: array_inline.leo
path: test
content: "[[1,2,3],[1,2,3]]"
- ArrayInline:
elements:
@ -277,14 +277,14 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 4
path: array_inline.leo
path: test
content: "[[]]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: array_inline.leo
path: test
content: "[[]]"
- ArrayInline:
elements:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 2
col_stop: 4
path: array_inline.leo
path: test
content: "[[], []]"
- Expression:
ArrayInline:
@ -306,12 +306,12 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 8
path: array_inline.leo
path: test
content: "[[], []]"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 9
path: array_inline.leo
path: test
content: "[[], []]"

0
tests/parser/expression/array_inline_fail.leo.out → tests/expectations/parser/parser/expression/array_inline_fail.leo.out
View File

68
tests/parser/expression/binary/add.leo.out → tests/expectations/parser/parser/expression/binary/add.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: add.leo
path: test
content: 1 + 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: add.leo
path: test
content: 1 + 1
op: Add
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: add.leo
path: test
content: 1 + 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: add.leo
path: test
content: 2+3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: add.leo
path: test
content: 2+3
op: Add
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: add.leo
path: test
content: 2+3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: add.leo
path: test
content: 1 + 2 + 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: add.leo
path: test
content: 1 + 2 + 3
op: Add
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: add.leo
path: test
content: 1 + 2 + 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: add.leo
path: test
content: 1 + 2 + 3
op: Add
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: add.leo
path: test
content: 1 + 2 + 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: add.leo
path: test
content: 1 * 2 + 3 * 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: add.leo
path: test
content: 1 * 2 + 3 * 4
op: Mul
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: add.leo
path: test
content: 1 * 2 + 3 * 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: add.leo
path: test
content: 1 * 2 + 3 * 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: add.leo
path: test
content: 1 * 2 + 3 * 4
op: Mul
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: add.leo
path: test
content: 1 * 2 + 3 * 4
op: Add
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: add.leo
path: test
content: 1 * 2 + 3 * 4
- Binary:
left:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: add.leo
path: test
content: 1 + 2 - 3
right:
Value:
@ -199,7 +199,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: add.leo
path: test
content: 1 + 2 - 3
op: Add
span:
@ -207,7 +207,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: add.leo
path: test
content: 1 + 2 - 3
right:
Value:
@ -217,7 +217,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: add.leo
path: test
content: 1 + 2 - 3
op: Sub
span:
@ -225,7 +225,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: add.leo
path: test
content: 1 + 2 - 3
- Binary:
left:
@ -240,7 +240,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Value:
@ -250,7 +250,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Mul
span:
@ -258,7 +258,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Binary:
@ -270,7 +270,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Value:
@ -280,7 +280,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Mul
span:
@ -288,7 +288,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Add
span:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Binary:
@ -308,7 +308,7 @@ outputs:
line_stop: 1
col_start: 17
col_stop: 18
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Value:
@ -318,7 +318,7 @@ outputs:
line_stop: 1
col_start: 21
col_stop: 22
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Mul
span:
@ -326,7 +326,7 @@ outputs:
line_stop: 1
col_start: 17
col_stop: 22
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Sub
span:
@ -334,5 +334,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 22
path: add.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6

22
tests/parser/expression/binary/and.leo.out → tests/expectations/parser/parser/expression/binary/and.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 5
path: and.leo
path: test
content: true && false
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: and.leo
path: test
content: true && false
op: And
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: and.leo
path: test
content: true && false
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: and.leo
path: test
content: false&&true
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 8
col_stop: 12
path: and.leo
path: test
content: false&&true
op: And
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: and.leo
path: test
content: false&&true
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 5
path: and.leo
path: test
content: true&&false&&true
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 7
col_stop: 12
path: and.leo
path: test
content: true&&false&&true
op: And
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: and.leo
path: test
content: true&&false&&true
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 18
path: and.leo
path: test
content: true&&false&&true
op: And
span:
@ -107,5 +107,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 18
path: and.leo
path: test
content: true&&false&&true

36
tests/parser/expression/binary/div.leo.out → tests/expectations/parser/parser/expression/binary/div.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: div.leo
path: test
content: 1 / 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: div.leo
path: test
content: 1 / 1
op: Div
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: div.leo
path: test
content: 1 / 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: div.leo
path: test
content: 2/3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: div.leo
path: test
content: 2/3
op: Div
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: div.leo
path: test
content: 2/3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: div.leo
path: test
content: 1 / 2 / 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: div.leo
path: test
content: 1 / 2 / 3
op: Div
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: div.leo
path: test
content: 1 / 2 / 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: div.leo
path: test
content: 1 / 2 / 3
op: Div
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: div.leo
path: test
content: 1 / 2 / 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: div.leo
path: test
content: 1 ** 2 / 3 ** 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: div.leo
path: test
content: 1 ** 2 / 3 ** 4
op: Pow
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: div.leo
path: test
content: 1 ** 2 / 3 ** 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: div.leo
path: test
content: 1 ** 2 / 3 ** 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 15
col_stop: 16
path: div.leo
path: test
content: 1 ** 2 / 3 ** 4
op: Pow
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 16
path: div.leo
path: test
content: 1 ** 2 / 3 ** 4
op: Div
span:
@ -176,5 +176,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 16
path: div.leo
path: test
content: 1 ** 2 / 3 ** 4

68
tests/parser/expression/binary/eq.leo.out → tests/expectations/parser/parser/expression/binary/eq.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: eq.leo
path: test
content: 1 == 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: eq.leo
path: test
content: 1 == 1
op: Eq
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: eq.leo
path: test
content: 1 == 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: eq.leo
path: test
content: 2==3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 4
col_stop: 5
path: eq.leo
path: test
content: 2==3
op: Eq
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 5
path: eq.leo
path: test
content: 2==3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: eq.leo
path: test
content: 1 == 2 == 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: eq.leo
path: test
content: 1 == 2 == 3
op: Eq
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: eq.leo
path: test
content: 1 == 2 == 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: eq.leo
path: test
content: 1 == 2 == 3
op: Eq
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: eq.leo
path: test
content: 1 == 2 == 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: eq.leo
path: test
content: 1 < 2 == 3 < 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: eq.leo
path: test
content: 1 < 2 == 3 < 4
op: Lt
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: eq.leo
path: test
content: 1 < 2 == 3 < 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: eq.leo
path: test
content: 1 < 2 == 3 < 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 15
path: eq.leo
path: test
content: 1 < 2 == 3 < 4
op: Lt
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 15
path: eq.leo
path: test
content: 1 < 2 == 3 < 4
op: Eq
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: eq.leo
path: test
content: 1 < 2 == 3 < 4
- Binary:
left:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: eq.leo
path: test
content: 1 == 2 == 3
right:
Value:
@ -199,7 +199,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: eq.leo
path: test
content: 1 == 2 == 3
op: Eq
span:
@ -207,7 +207,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: eq.leo
path: test
content: 1 == 2 == 3
right:
Value:
@ -217,7 +217,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: eq.leo
path: test
content: 1 == 2 == 3
op: Eq
span:
@ -225,7 +225,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: eq.leo
path: test
content: 1 == 2 == 3
- Binary:
left:
@ -240,7 +240,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
right:
Value:
@ -250,7 +250,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
op: Lt
span:
@ -258,7 +258,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
right:
Binary:
@ -270,7 +270,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
right:
Value:
@ -280,7 +280,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 15
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
op: Lt
span:
@ -288,7 +288,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 15
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
op: Eq
span:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
right:
Binary:
@ -308,7 +308,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 20
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
right:
Value:
@ -318,7 +318,7 @@ outputs:
line_stop: 1
col_start: 23
col_stop: 24
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
op: Lt
span:
@ -326,7 +326,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 24
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6
op: Eq
span:
@ -334,5 +334,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 24
path: eq.leo
path: test
content: 1 < 2 == 3 < 4 == 5 < 6

48
tests/parser/expression/binary/exp.leo.out → tests/expectations/parser/parser/expression/binary/exp.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: exp.leo
path: test
content: 1 ** 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: exp.leo
path: test
content: 1 ** 1
op: Pow
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: exp.leo
path: test
content: 1 ** 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: exp.leo
path: test
content: 2**3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 4
col_stop: 5
path: exp.leo
path: test
content: 2**3
op: Pow
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 5
path: exp.leo
path: test
content: 2**3
- Binary:
left:
@ -69,7 +69,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: exp.leo
path: test
content: 1 ** 2 ** 3
right:
Binary:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: exp.leo
path: test
content: 1 ** 2 ** 3
right:
Value:
@ -91,7 +91,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: exp.leo
path: test
content: 1 ** 2 ** 3
op: Pow
span:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 12
path: exp.leo
path: test
content: 1 ** 2 ** 3
op: Pow
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: exp.leo
path: test
content: 1 ** 2 ** 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8
target_type:
IntegerType: I8
@ -129,7 +129,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 8
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8
right:
Cast:
@ -141,7 +141,7 @@ outputs:
line_stop: 1
col_start: 12
col_stop: 13
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8
target_type:
IntegerType: I8
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 12
col_stop: 19
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8
op: Pow
span:
@ -158,7 +158,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 19
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8
- Binary:
left:
@ -171,7 +171,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8 ** 5 as i8
target_type:
IntegerType: I8
@ -180,7 +180,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 8
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8 ** 5 as i8
right:
Binary:
@ -194,7 +194,7 @@ outputs:
line_stop: 1
col_start: 12
col_stop: 13
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8 ** 5 as i8
target_type:
IntegerType: I8
@ -203,7 +203,7 @@ outputs:
line_stop: 1
col_start: 12
col_stop: 19
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8 ** 5 as i8
right:
Cast:
@ -215,7 +215,7 @@ outputs:
line_stop: 1
col_start: 23
col_stop: 24
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8 ** 5 as i8
target_type:
IntegerType: I8
@ -224,7 +224,7 @@ outputs:
line_stop: 1
col_start: 23
col_stop: 30
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8 ** 5 as i8
op: Pow
span:
@ -232,7 +232,7 @@ outputs:
line_stop: 1
col_start: 12
col_stop: 30
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8 ** 5 as i8
op: Pow
span:
@ -240,5 +240,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 30
path: exp.leo
path: test
content: 1 as i8 ** 3 as i8 ** 5 as i8

68
tests/parser/expression/binary/gt.leo.out → tests/expectations/parser/parser/expression/binary/gt.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gt.leo
path: test
content: 1 > 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: gt.leo
path: test
content: 1 > 1
op: Gt
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: gt.leo
path: test
content: 1 > 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gt.leo
path: test
content: 2>3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: gt.leo
path: test
content: 2>3
op: Gt
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: gt.leo
path: test
content: 2>3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gt.leo
path: test
content: 1 > 2 > 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: gt.leo
path: test
content: 1 > 2 > 3
op: Gt
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: gt.leo
path: test
content: 1 > 2 > 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: gt.leo
path: test
content: 1 > 2 > 3
op: Gt
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: gt.leo
path: test
content: 1 > 2 > 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gt.leo
path: test
content: 1 + 2 > 3 + 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: gt.leo
path: test
content: 1 + 2 > 3 + 4
op: Add
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: gt.leo
path: test
content: 1 + 2 > 3 + 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: gt.leo
path: test
content: 1 + 2 > 3 + 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: gt.leo
path: test
content: 1 + 2 > 3 + 4
op: Add
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: gt.leo
path: test
content: 1 + 2 > 3 + 4
op: Gt
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: gt.leo
path: test
content: 1 + 2 > 3 + 4
- Binary:
left:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gt.leo
path: test
content: 1 > 2 > 3
right:
Value:
@ -199,7 +199,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: gt.leo
path: test
content: 1 > 2 > 3
op: Gt
span:
@ -207,7 +207,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: gt.leo
path: test
content: 1 > 2 > 3
right:
Value:
@ -217,7 +217,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: gt.leo
path: test
content: 1 > 2 > 3
op: Gt
span:
@ -225,7 +225,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: gt.leo
path: test
content: 1 > 2 > 3
- Binary:
left:
@ -240,7 +240,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
right:
Value:
@ -250,7 +250,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
op: Add
span:
@ -258,7 +258,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
right:
Binary:
@ -270,7 +270,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
right:
Value:
@ -280,7 +280,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
op: Add
span:
@ -288,7 +288,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
op: Gt
span:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
right:
Binary:
@ -308,7 +308,7 @@ outputs:
line_stop: 1
col_start: 17
col_stop: 18
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
right:
Value:
@ -318,7 +318,7 @@ outputs:
line_stop: 1
col_start: 21
col_stop: 22
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
op: Add
span:
@ -326,7 +326,7 @@ outputs:
line_stop: 1
col_start: 17
col_stop: 22
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6
op: Gt
span:
@ -334,5 +334,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 22
path: gt.leo
path: test
content: 1 + 2 > 3 + 4 > 5 + 6

68
tests/parser/expression/binary/gte.leo.out → tests/expectations/parser/parser/expression/binary/gte.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gte.leo
path: test
content: 1 >= 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: gte.leo
path: test
content: 1 >= 1
op: Ge
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: gte.leo
path: test
content: 1 >= 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gte.leo
path: test
content: 2 >= 3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: gte.leo
path: test
content: 2 >= 3
op: Ge
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: gte.leo
path: test
content: 2 >= 3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gte.leo
path: test
content: 1 >= 2 >= 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: gte.leo
path: test
content: 1 >= 2 >= 3
op: Ge
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: gte.leo
path: test
content: 1 >= 2 >= 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: gte.leo
path: test
content: 1 >= 2 >= 3
op: Ge
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: gte.leo
path: test
content: 1 >= 2 >= 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4
op: Add
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 15
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4
op: Add
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 15
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4
op: Ge
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4
- Binary:
left:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gte.leo
path: test
content: 1 >= 2 >= 3
right:
Value:
@ -199,7 +199,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: gte.leo
path: test
content: 1 >= 2 >= 3
op: Ge
span:
@ -207,7 +207,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: gte.leo
path: test
content: 1 >= 2 >= 3
right:
Value:
@ -217,7 +217,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: gte.leo
path: test
content: 1 >= 2 >= 3
op: Ge
span:
@ -225,7 +225,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: gte.leo
path: test
content: 1 >= 2 >= 3
- Binary:
left:
@ -240,7 +240,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
right:
Value:
@ -250,7 +250,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
op: Add
span:
@ -258,7 +258,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
right:
Binary:
@ -270,7 +270,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
right:
Value:
@ -280,7 +280,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 15
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
op: Add
span:
@ -288,7 +288,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 15
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
op: Ge
span:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
right:
Binary:
@ -308,7 +308,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 20
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
right:
Value:
@ -318,7 +318,7 @@ outputs:
line_stop: 1
col_start: 23
col_stop: 24
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
op: Add
span:
@ -326,7 +326,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 24
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6
op: Ge
span:
@ -334,5 +334,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 24
path: gte.leo
path: test
content: 1 + 2 >= 3 + 4 >= 5 + 6

68
tests/parser/expression/binary/lt.leo.out → tests/expectations/parser/parser/expression/binary/lt.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lt.leo
path: test
content: 1 < 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: lt.leo
path: test
content: 1 < 1
op: Lt
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: lt.leo
path: test
content: 1 < 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lt.leo
path: test
content: 2<3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: lt.leo
path: test
content: 2<3
op: Lt
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: lt.leo
path: test
content: 2<3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lt.leo
path: test
content: 1 < 2 < 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: lt.leo
path: test
content: 1 < 2 < 3
op: Lt
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: lt.leo
path: test
content: 1 < 2 < 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: lt.leo
path: test
content: 1 < 2 < 3
op: Lt
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: lt.leo
path: test
content: 1 < 2 < 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lt.leo
path: test
content: 1 + 2 < 3 + 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: lt.leo
path: test
content: 1 + 2 < 3 + 4
op: Add
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: lt.leo
path: test
content: 1 + 2 < 3 + 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: lt.leo
path: test
content: 1 + 2 < 3 + 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: lt.leo
path: test
content: 1 + 2 < 3 + 4
op: Add
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: lt.leo
path: test
content: 1 + 2 < 3 + 4
op: Lt
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: lt.leo
path: test
content: 1 + 2 < 3 + 4
- Binary:
left:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lt.leo
path: test
content: 1 < 2 < 3
right:
Value:
@ -199,7 +199,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: lt.leo
path: test
content: 1 < 2 < 3
op: Lt
span:
@ -207,7 +207,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: lt.leo
path: test
content: 1 < 2 < 3
right:
Value:
@ -217,7 +217,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: lt.leo
path: test
content: 1 < 2 < 3
op: Lt
span:
@ -225,7 +225,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: lt.leo
path: test
content: 1 < 2 < 3
- Binary:
left:
@ -240,7 +240,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
right:
Value:
@ -250,7 +250,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
op: Add
span:
@ -258,7 +258,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
right:
Binary:
@ -270,7 +270,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
right:
Value:
@ -280,7 +280,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
op: Add
span:
@ -288,7 +288,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
op: Lt
span:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
right:
Binary:
@ -308,7 +308,7 @@ outputs:
line_stop: 1
col_start: 17
col_stop: 18
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
right:
Value:
@ -318,7 +318,7 @@ outputs:
line_stop: 1
col_start: 21
col_stop: 22
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
op: Add
span:
@ -326,7 +326,7 @@ outputs:
line_stop: 1
col_start: 17
col_stop: 22
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6
op: Lt
span:
@ -334,5 +334,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 22
path: lt.leo
path: test
content: 1 + 2 < 3 + 4 < 5 + 6

68
tests/parser/expression/binary/lte.leo.out → tests/expectations/parser/parser/expression/binary/lte.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lte.leo
path: test
content: 1 <= 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: lte.leo
path: test
content: 1 <= 1
op: Le
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: lte.leo
path: test
content: 1 <= 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lte.leo
path: test
content: 2 <= 3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: lte.leo
path: test
content: 2 <= 3
op: Le
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: lte.leo
path: test
content: 2 <= 3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lte.leo
path: test
content: 1 <= 2 <= 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: lte.leo
path: test
content: 1 <= 2 <= 3
op: Le
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: lte.leo
path: test
content: 1 <= 2 <= 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: lte.leo
path: test
content: 1 <= 2 <= 3
op: Le
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: lte.leo
path: test
content: 1 <= 2 <= 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4
op: Add
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 15
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4
op: Add
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 15
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4
op: Le
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4
- Binary:
left:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lte.leo
path: test
content: 1 <= 2 <= 3
right:
Value:
@ -199,7 +199,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: lte.leo
path: test
content: 1 <= 2 <= 3
op: Le
span:
@ -207,7 +207,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: lte.leo
path: test
content: 1 <= 2 <= 3
right:
Value:
@ -217,7 +217,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: lte.leo
path: test
content: 1 <= 2 <= 3
op: Le
span:
@ -225,7 +225,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: lte.leo
path: test
content: 1 <= 2 <= 3
- Binary:
left:
@ -240,7 +240,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
right:
Value:
@ -250,7 +250,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
op: Add
span:
@ -258,7 +258,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
right:
Binary:
@ -270,7 +270,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
right:
Value:
@ -280,7 +280,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 15
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
op: Add
span:
@ -288,7 +288,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 15
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
op: Le
span:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
right:
Binary:
@ -308,7 +308,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 20
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
right:
Value:
@ -318,7 +318,7 @@ outputs:
line_stop: 1
col_start: 23
col_stop: 24
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
op: Add
span:
@ -326,7 +326,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 24
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6
op: Le
span:
@ -334,5 +334,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 24
path: lte.leo
path: test
content: 1 + 2 <= 3 + 4 <= 5 + 6

58
tests/parser/expression/binary/mul.leo.out → tests/expectations/parser/parser/expression/binary/mul.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: mul.leo
path: test
content: 1 * 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: mul.leo
path: test
content: 1 * 1
op: Mul
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: mul.leo
path: test
content: 1 * 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: mul.leo
path: test
content: 2*3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: mul.leo
path: test
content: 2*3
op: Mul
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: mul.leo
path: test
content: 2*3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: mul.leo
path: test
content: 1 * 2 * 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: mul.leo
path: test
content: 1 * 2 * 3
op: Mul
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: mul.leo
path: test
content: 1 * 2 * 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: mul.leo
path: test
content: 1 * 2 * 3
op: Mul
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: mul.leo
path: test
content: 1 * 2 * 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4
op: Pow
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 15
col_stop: 16
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4
op: Pow
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 16
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4
op: Mul
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 16
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4
- Binary:
left:
@ -191,7 +191,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
right:
Value:
@ -201,7 +201,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
op: Pow
span:
@ -209,7 +209,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
right:
Binary:
@ -221,7 +221,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
right:
Value:
@ -231,7 +231,7 @@ outputs:
line_stop: 1
col_start: 15
col_stop: 16
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
op: Pow
span:
@ -239,7 +239,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 16
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
op: Mul
span:
@ -247,7 +247,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 16
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
right:
Binary:
@ -259,7 +259,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 20
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
right:
Value:
@ -269,7 +269,7 @@ outputs:
line_stop: 1
col_start: 24
col_stop: 25
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
op: Pow
span:
@ -277,7 +277,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 25
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6
op: Div
span:
@ -285,5 +285,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 25
path: mul.leo
path: test
content: 1 ** 2 * 3 ** 4 / 5 ** 6

68
tests/parser/expression/binary/ne.leo.out → tests/expectations/parser/parser/expression/binary/ne.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: ne.leo
path: test
content: 1 != 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: ne.leo
path: test
content: 1 != 1
op: Ne
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: ne.leo
path: test
content: 1 != 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: ne.leo
path: test
content: 2!=3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 4
col_stop: 5
path: ne.leo
path: test
content: 2!=3
op: Ne
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 5
path: ne.leo
path: test
content: 2!=3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: ne.leo
path: test
content: 1 != 2 != 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: ne.leo
path: test
content: 1 != 2 != 3
op: Ne
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: ne.leo
path: test
content: 1 != 2 != 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: ne.leo
path: test
content: 1 != 2 != 3
op: Ne
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: ne.leo
path: test
content: 1 != 2 != 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: ne.leo
path: test
content: 1 < 2 != 3 < 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: ne.leo
path: test
content: 1 < 2 != 3 < 4
op: Lt
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: ne.leo
path: test
content: 1 < 2 != 3 < 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: ne.leo
path: test
content: 1 < 2 != 3 < 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 15
path: ne.leo
path: test
content: 1 < 2 != 3 < 4
op: Lt
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 15
path: ne.leo
path: test
content: 1 < 2 != 3 < 4
op: Ne
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: ne.leo
path: test
content: 1 < 2 != 3 < 4
- Binary:
left:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: ne.leo
path: test
content: 1 != 2 != 3
right:
Value:
@ -199,7 +199,7 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 7
path: ne.leo
path: test
content: 1 != 2 != 3
op: Ne
span:
@ -207,7 +207,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 7
path: ne.leo
path: test
content: 1 != 2 != 3
right:
Value:
@ -217,7 +217,7 @@ outputs:
line_stop: 1
col_start: 11
col_stop: 12
path: ne.leo
path: test
content: 1 != 2 != 3
op: Ne
span:
@ -225,7 +225,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 12
path: ne.leo
path: test
content: 1 != 2 != 3
- Binary:
left:
@ -240,7 +240,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
right:
Value:
@ -250,7 +250,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
op: Lt
span:
@ -258,7 +258,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
right:
Binary:
@ -270,7 +270,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 11
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
right:
Value:
@ -280,7 +280,7 @@ outputs:
line_stop: 1
col_start: 14
col_stop: 15
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
op: Lt
span:
@ -288,7 +288,7 @@ outputs:
line_stop: 1
col_start: 10
col_stop: 15
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
op: Ne
span:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 15
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
right:
Binary:
@ -308,7 +308,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 20
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
right:
Value:
@ -318,7 +318,7 @@ outputs:
line_stop: 1
col_start: 23
col_stop: 24
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
op: Lt
span:
@ -326,7 +326,7 @@ outputs:
line_stop: 1
col_start: 19
col_stop: 24
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6
op: Ne
span:
@ -334,5 +334,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 24
path: ne.leo
path: test
content: 1 < 2 != 3 < 4 != 5 < 6

68
tests/parser/expression/binary/or.leo.out → tests/expectations/parser/parser/expression/binary/or.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: or.leo
path: test
content: 1 + 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: or.leo
path: test
content: 1 + 1
op: Add
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: or.leo
path: test
content: 1 + 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: or.leo
path: test
content: 2+3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: or.leo
path: test
content: 2+3
op: Add
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: or.leo
path: test
content: 2+3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: or.leo
path: test
content: 1 + 2 + 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: or.leo
path: test
content: 1 + 2 + 3
op: Add
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: or.leo
path: test
content: 1 + 2 + 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: or.leo
path: test
content: 1 + 2 + 3
op: Add
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: or.leo
path: test
content: 1 + 2 + 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: or.leo
path: test
content: 1 * 2 + 3 * 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: or.leo
path: test
content: 1 * 2 + 3 * 4
op: Mul
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: or.leo
path: test
content: 1 * 2 + 3 * 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: or.leo
path: test
content: 1 * 2 + 3 * 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: or.leo
path: test
content: 1 * 2 + 3 * 4
op: Mul
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: or.leo
path: test
content: 1 * 2 + 3 * 4
op: Add
span:
@ -176,7 +176,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: or.leo
path: test
content: 1 * 2 + 3 * 4
- Binary:
left:
@ -189,7 +189,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: or.leo
path: test
content: 1 + 2 - 3
right:
Value:
@ -199,7 +199,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: or.leo
path: test
content: 1 + 2 - 3
op: Add
span:
@ -207,7 +207,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: or.leo
path: test
content: 1 + 2 - 3
right:
Value:
@ -217,7 +217,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: or.leo
path: test
content: 1 + 2 - 3
op: Sub
span:
@ -225,7 +225,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: or.leo
path: test
content: 1 + 2 - 3
- Binary:
left:
@ -240,7 +240,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Value:
@ -250,7 +250,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Mul
span:
@ -258,7 +258,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Binary:
@ -270,7 +270,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Value:
@ -280,7 +280,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Mul
span:
@ -288,7 +288,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Add
span:
@ -296,7 +296,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Binary:
@ -308,7 +308,7 @@ outputs:
line_stop: 1
col_start: 17
col_stop: 18
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
right:
Value:
@ -318,7 +318,7 @@ outputs:
line_stop: 1
col_start: 21
col_stop: 22
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Mul
span:
@ -326,7 +326,7 @@ outputs:
line_stop: 1
col_start: 17
col_stop: 22
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6
op: Sub
span:
@ -334,5 +334,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 22
path: or.leo
path: test
content: 1 * 2 + 3 * 4 - 5 * 6

36
tests/parser/expression/binary/sub.leo.out → tests/expectations/parser/parser/expression/binary/sub.leo.out
View File

@ -11,7 +11,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: sub.leo
path: test
content: 1 - 1
right:
Value:
@ -21,7 +21,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: sub.leo
path: test
content: 1 - 1
op: Sub
span:
@ -29,7 +29,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: sub.leo
path: test
content: 1 - 1
- Binary:
left:
@ -40,7 +40,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: sub.leo
path: test
content: 2-3
right:
Value:
@ -50,7 +50,7 @@ outputs:
line_stop: 1
col_start: 3
col_stop: 4
path: sub.leo
path: test
content: 2-3
op: Sub
span:
@ -58,7 +58,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 4
path: sub.leo
path: test
content: 2-3
- Binary:
left:
@ -71,7 +71,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: sub.leo
path: test
content: 1 - 2 - 3
right:
Value:
@ -81,7 +81,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: sub.leo
path: test
content: 1 - 2 - 3
op: Sub
span:
@ -89,7 +89,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: sub.leo
path: test
content: 1 - 2 - 3
right:
Value:
@ -99,7 +99,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: sub.leo
path: test
content: 1 - 2 - 3
op: Sub
span:
@ -107,7 +107,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: sub.leo
path: test
content: 1 - 2 - 3
- Binary:
left:
@ -120,7 +120,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 2
path: sub.leo
path: test
content: 1 * 2 - 3 * 4
right:
Value:
@ -130,7 +130,7 @@ outputs:
line_stop: 1
col_start: 5
col_stop: 6
path: sub.leo
path: test
content: 1 * 2 - 3 * 4
op: Mul
span:
@ -138,7 +138,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: sub.leo
path: test
content: 1 * 2 - 3 * 4
right:
Binary:
@ -150,7 +150,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 10
path: sub.leo
path: test
content: 1 * 2 - 3 * 4
right:
Value:
@ -160,7 +160,7 @@ outputs:
line_stop: 1
col_start: 13
col_stop: 14
path: sub.leo
path: test
content: 1 * 2 - 3 * 4
op: Mul
span:
@ -168,7 +168,7 @@ outputs:
line_stop: 1
col_start: 9
col_stop: 14
path: sub.leo
path: test
content: 1 * 2 - 3 * 4
op: Sub
span:
@ -176,5 +176,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 14
path: sub.leo
path: test
content: 1 * 2 - 3 * 4

56
tests/parser/expression/cast.leo.out → tests/expectations/parser/parser/expression/cast.leo.out
View File

@ -4,7 +4,7 @@ expectation: Pass
outputs:
- Cast:
inner:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as u8\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as u8\\\"}\"}"
target_type:
IntegerType: U8
span:
@ -12,23 +12,23 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 8
path: cast.leo
path: test
content: x as u8
- Cast:
inner:
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"y as id\\\"}\"}"
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"y as id\\\"}\"}"
target_type:
Circuit: "{\"name\":\"id\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":8,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"y as id\\\"}\"}"
Circuit: "{\"name\":\"id\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"y as id\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: cast.leo
path: test
content: y as id
- Cast:
inner:
Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"z as u32\\\"}\"}"
Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"z as u32\\\"}\"}"
target_type:
IntegerType: U32
span:
@ -36,11 +36,11 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 9
path: cast.leo
path: test
content: z as u32
- Cast:
inner:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as i128\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as i128\\\"}\"}"
target_type:
IntegerType: I128
span:
@ -48,13 +48,13 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: cast.leo
path: test
content: x as i128
- Cast:
inner:
Cast:
inner:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as u8 as u128\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as u8 as u128\\\"}\"}"
target_type:
IntegerType: U8
span:
@ -62,7 +62,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 8
path: cast.leo
path: test
content: x as u8 as u128
target_type:
IntegerType: U128
@ -71,39 +71,39 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 16
path: cast.leo
path: test
content: x as u8 as u128
- Cast:
inner:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as field\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as field\\\"}\"}"
target_type: Field
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 11
path: cast.leo
path: test
content: x as field
- Cast:
inner:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as group\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as group\\\"}\"}"
target_type: Group
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 11
path: cast.leo
path: test
content: x as group
- Binary:
left:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
right:
Binary:
left:
Cast:
inner:
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
target_type:
IntegerType: U32
span:
@ -111,17 +111,17 @@ outputs:
line_stop: 1
col_start: 6
col_stop: 14
path: cast.leo
path: test
content: x ** y as u32 ** z
right:
Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
op: Pow
span:
line_start: 1
line_stop: 1
col_start: 6
col_stop: 19
path: cast.leo
path: test
content: x ** y as u32 ** z
op: Pow
span:
@ -129,7 +129,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 19
path: cast.leo
path: test
content: x ** y as u32 ** z
- Value:
Implicit:
@ -144,14 +144,14 @@ outputs:
inner:
Unary:
inner:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":2,\\\"col_stop\\\":3,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"!x as u32\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":2,\\\"col_stop\\\":3,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"!x as u32\\\"}\"}"
op: Not
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 3
path: cast.leo
path: test
content: "!x as u32"
target_type:
IntegerType: U32
@ -160,20 +160,20 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: cast.leo
path: test
content: "!x as u32"
- Cast:
inner:
Unary:
inner:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":2,\\\"col_stop\\\":3,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"-x as u32\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":2,\\\"col_stop\\\":3,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"-x as u32\\\"}\"}"
op: Negate
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 3
path: cast.leo
path: test
content: "-x as u32"
target_type:
IntegerType: U32
@ -182,5 +182,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 10
path: cast.leo
path: test
content: "-x as u32"

60
tests/parser/expression/circuit_init.leo.out → tests/expectations/parser/parser/expression/circuit_init.leo.out
View File

@ -3,111 +3,111 @@ namespace: ParseExpression
expectation: Pass
outputs:
- CircuitInit:
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x {}\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x {}\\\"}\"}"
members: []
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: circuit_init.leo
path: test
content: "x {}"
- CircuitInit:
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x {y}\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x {y}\\\"}\"}"
members:
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x {y}\\\"}\"}"
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x {y}\\\"}\"}"
expression: ~
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 6
path: circuit_init.leo
path: test
content: "x {y}"
- CircuitInit:
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y}\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y}\\\"}\"}"
members:
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y}\\\"}\"}"
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y}\\\"}\"}"
expression: ~
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 5
path: circuit_init.leo
path: test
content: "x{y}"
- CircuitInit:
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{}\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{}\\\"}\"}"
members: []
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 4
path: circuit_init.leo
path: test
content: "x{}"
- CircuitInit:
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
members:
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
expression:
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: circuit_init.leo
path: test
content: "x{y: y}"
- CircuitInit:
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
members:
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
expression:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: circuit_init.leo
path: test
content: "x{y: x}"
- CircuitInit:
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
members:
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
expression:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 9
path: circuit_init.leo
path: test
content: "x{y: x,}"
- CircuitInit:
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
members:
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
- identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
expression:
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
- identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
- identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
expression:
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 13
path: circuit_init.leo
path: test
content: "x{y:x, x:y,}"
- CircuitInit:
name: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"Self {}\\\"}\"}"
name: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"Self {}\\\"}\"}"
members: []
span:
line_start: 1
line_stop: 1
col_start: 1
col_stop: 8
path: circuit_init.leo
path: test
content: "Self {}"

0
tests/parser/expression/circuit_init_fail.leo.out → tests/expectations/parser/parser/expression/circuit_init_fail.leo.out
View File

38
tests/parser/expression/ident.leo.out → tests/expectations/parser/parser/expression/ident.leo.out
View File

@ -2,22 +2,22 @@
namespace: ParseExpression
expectation: Pass
outputs:
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"x\\\"}\"}"
- Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"X\\\"}\"}"
- Identifier: "{\"name\":\"xxx\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":4,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"xxx\\\"}\"}"
- Identifier: "{\"name\":\"XXX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":4,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"XXX\\\"}\"}"
- Identifier: "{\"name\":\"x1\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"x1\\\"}\"}"
- Identifier: "{\"name\":\"xu32\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"xu32\\\"}\"}"
- Identifier: "{\"name\":\"testx\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"testx\\\"}\"}"
- Identifier: "{\"name\":\"truex\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"truex\\\"}\"}"
- Identifier: "{\"name\":\"TRUE\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"TRUE\\\"}\"}"
- Identifier: "{\"name\":\"testX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"testX\\\"}\"}"
- Identifier: "{\"name\":\"letX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"letX\\\"}\"}"
- Identifier: "{\"name\":\"constX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":7,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"constX\\\"}\"}"
- Identifier: "{\"name\":\"test_test\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":10,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"test_test\\\"}\"}"
- Identifier: "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"self\\\"}\"}"
- Identifier: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"Self\\\"}\"}"
- Identifier: "{\"name\":\"input\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"input\\\"}\"}"
- Identifier: "{\"name\":\"selfX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"selfX\\\"}\"}"
- Identifier: "{\"name\":\"SelfX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"SelfX\\\"}\"}"
- Identifier: "{\"name\":\"inputX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":7,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"inputX\\\"}\"}"
- Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x\\\"}\"}"
- Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X\\\"}\"}"
- Identifier: "{\"name\":\"xxx\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"xxx\\\"}\"}"
- Identifier: "{\"name\":\"XXX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"XXX\\\"}\"}"
- Identifier: "{\"name\":\"x1\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x1\\\"}\"}"
- Identifier: "{\"name\":\"xu32\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"xu32\\\"}\"}"
- Identifier: "{\"name\":\"testx\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"testx\\\"}\"}"
- Identifier: "{\"name\":\"truex\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"truex\\\"}\"}"
- Identifier: "{\"name\":\"TRUE\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"TRUE\\\"}\"}"
- Identifier: "{\"name\":\"testX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"testX\\\"}\"}"
- Identifier: "{\"name\":\"letX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"letX\\\"}\"}"
- Identifier: "{\"name\":\"constX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"constX\\\"}\"}"
- Identifier: "{\"name\":\"test_test\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"test_test\\\"}\"}"
- Identifier: "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"self\\\"}\"}"
- Identifier: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"Self\\\"}\"}"
- Identifier: "{\"name\":\"input\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"input\\\"}\"}"
- Identifier: "{\"name\":\"selfX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"selfX\\\"}\"}"
- Identifier: "{\"name\":\"SelfX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"SelfX\\\"}\"}"
- Identifier: "{\"name\":\"inputX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"inputX\\\"}\"}"

0
tests/parser/expression/literal/address.leo.out → tests/expectations/parser/parser/expression/literal/address.leo.out
View File

0
tests/parser/expression/literal/address_fail.leo.out → tests/expectations/parser/parser/expression/literal/address_fail.leo.out
View File

8
tests/parser/expression/literal/address_parse.leo.out → tests/expectations/parser/parser/expression/literal/address_parse.leo.out
View File

@ -9,7 +9,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 64
path: address_parse.leo
path: test
content: aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8
- Value:
Address:
@ -18,7 +18,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 64
path: address_parse.leo
path: test
content: aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j9
- Value:
Address:
@ -27,7 +27,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 64
path: address_parse.leo
path: test
content: aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57d9
- Value:
Address:
@ -36,5 +36,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 64
path: address_parse.leo
path: test
content: aleo1aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8st

0
tests/parser/expression/literal/bool.leo.out → tests/expectations/parser/parser/expression/literal/bool.leo.out
View File

4
tests/parser/expression/literal/bool_parse.leo.out → tests/expectations/parser/parser/expression/literal/bool_parse.leo.out
View File

@ -9,7 +9,7 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 5
path: bool_parse.leo
path: test
content: "true"
- Value:
Boolean:
@ -18,5 +18,5 @@ outputs:
line_stop: 1
col_start: 1
col_stop: 6
path: bool_parse.leo
path: test
content: "false"

0
tests/parser/expression/literal/comment.leo.out → tests/expectations/parser/parser/expression/literal/comment.leo.out
View File

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