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

Merge pull request #1339 from AleoHQ/feature/built-ins

Browse Source 
[Feature] Leo stdlib & built-ins
This commit is contained in:
gluax 2021-09-14 22:04:02 -07:00 committed by GitHub
commit 2cbf62ef0a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
374 changed files with 1943 additions and 1099 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
Cargo.lock generated
View File

@ -925,6 +925,12 @@ version = "0.25.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0a01e0497841a3b2db4f8afa483cce65f7e96a3498bd6c541734792aeac8fe7"
[[package]]
name = "glob"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
[[package]]
name = "h2"
version = "0.3.3"
@ -1065,6 +1071,30 @@ dependencies = [
"unicode-normalization",
]
[[package]]
name = "include_dir"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "24b56e147e6187d61e9d0f039f10e070d0c0a887e24fe0bb9ca3f29bfde62cab"
dependencies = [
"glob",
"include_dir_impl",
"proc-macro-hack",
]
[[package]]
name = "include_dir_impl"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0a0c890c85da4bab7bce4204c707396bbd3c6c8a681716a51c8814cfc2b682df"
dependencies = [
"anyhow",
"proc-macro-hack",
"proc-macro2 1.0.27",
"quote 1.0.9",
"syn 1.0.73",
]
[[package]]
name = "indenter"
version = "0.3.3"
@ -1239,6 +1269,7 @@ dependencies = [
"leo-ast",
"leo-errors",
"leo-parser",
"leo-stdlib",
]
[[package]]
@ -1300,7 +1331,6 @@ name = "leo-imports"
version = "1.5.3"
dependencies = [
"indexmap",
"leo-asg",
"leo-ast",
"leo-ast-passes",
"leo-errors",
@ -1342,6 +1372,7 @@ dependencies = [
"leo-package",
"leo-parser",
"leo-state",
"leo-stdlib",
"leo-synthesizer",
"notify",
"rand 0.8.4",
@ -1416,6 +1447,17 @@ dependencies = [
"snarkvm-utilities",
]
[[package]]
name = "leo-stdlib"
version = "1.5.3"
dependencies = [
"include_dir",
"indexmap",
"leo-ast",
"leo-errors",
"leo-parser",
]
[[package]]
name = "leo-synthesizer"
version = "1.5.3"
@ -1993,6 +2035,12 @@ dependencies = [
"version_check",
]
[[package]]
name = "proc-macro-hack"
version = "0.5.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
[[package]]
name = "proc-macro2"
version = "0.4.30"

5
Cargo.toml
View File

@ -39,6 +39,7 @@ members = [
"package",
"parser",
"state",
"stdlib",
"synthesizer",
"test-framework"
]
@ -75,6 +76,10 @@ version = "1.5.3"
path = "./state"
version = "1.5.3"
[dependencies.leo-stdlib]
path = "./stdlib"
version = "1.5.3"
[dependencies.leo-synthesizer]
path = "./synthesizer"
version = "1.5.3"

23
asg/src/program/mod.rs
View File

@ -163,10 +163,26 @@ impl<'a> Program<'a> {
/// 4. resolve all asg nodes
///
pub fn new(context: AsgContext<'a>, program: &leo_ast::Program) -> Result<Program<'a>> {
let mut imported_aliases: IndexMap<String, &'a Alias<'a>> = IndexMap::new();
let mut imported_functions: IndexMap<String, &'a Function<'a>> = IndexMap::new();
let mut imported_circuits: IndexMap<String, &'a Circuit<'a>> = IndexMap::new();
let mut imported_global_consts: IndexMap<String, &'a DefinitionStatement<'a>> = IndexMap::new();
// Convert each sub AST.
// Import all prelude symbols on the way.
let mut imported_modules: IndexMap<Vec<String>, Program> = IndexMap::new();
for (package, program) in program.imports.iter() {
imported_modules.insert(package.clone(), Program::new(context, program)?);
let sub_program = Program::new(context, program)?;
imported_modules.insert(package.clone(), sub_program.clone());
let pretty_package = package.join(".");
if pretty_package.contains("std.prelude") {
imported_aliases.extend(sub_program.aliases.clone().into_iter());
imported_functions.extend(sub_program.functions.clone().into_iter());
imported_circuits.extend(sub_program.circuits.clone().into_iter());
imported_global_consts.extend(sub_program.global_consts.clone().into_iter());
}
}
let mut imported_symbols: Vec<(Vec<String>, ImportSymbol, Span)> = vec![];
@ -179,11 +195,6 @@ impl<'a> Program<'a> {
deduplicated_imports.insert(package.clone(), span.clone());
}
let mut imported_aliases: IndexMap<String, &'a Alias<'a>> = IndexMap::new();
let mut imported_functions: IndexMap<String, &'a Function<'a>> = IndexMap::new();
let mut imported_circuits: IndexMap<String, &'a Circuit<'a>> = IndexMap::new();
let mut imported_global_consts: IndexMap<String, &'a DefinitionStatement<'a>> = IndexMap::new();
for (package, symbol, span) in imported_symbols.into_iter() {
let pretty_package = package.join(".");

4
ast-passes/Cargo.toml
View File

@ -34,3 +34,7 @@ version = "1.5.3"
[dependencies.leo-parser]
path = "../parser"
version = "1.5.3"
[dependencies.leo-stdlib]
path = "../stdlib"
version = "1.5.3"

29
ast-passes/README.md
View File

@ -1 +1,30 @@
# leo-ast-passes
[![Crates.io](https://img.shields.io/crates/v/leo-ast.svg?color=neon)](https://crates.io/crates/leo-ast)
[![Authors](https://img.shields.io/badge/authors-Aleo-orange.svg)](../AUTHORS)
[![License](https://img.shields.io/badge/License-GPLv3-blue.svg)](./LICENSE.md)
## Usage
The code here is split into several usages. Each usage represents a different pass or modification when given an AST.
### Canonicalization
This pass of the code has a few changes it must complete:
- `Self` is not allowed outside a circuit.
- `Self` in circuits must be replaced with an Identifier containing the Circuit Name.
- Any 0 size array definitions should be rejected.
- Multi-size array definitions should be expanded such that `[0u8; (2, 3)]` becomes `[[0u8; 3] 2]`.
- Compound assignments become simple assignments such that `a += 2;` becomes `a = a + 2;`.
- Missing function output types are replaced with an empty tuple.
### Import Resolution
This pass iterates through the import statements(nestedly), resloving all imports. Thus adding the improted file's AST to the main AST.
In addition, it also handles forcibly importing the stdlib prelude files.
## Structure
Each different type of pass is located in its own directory within the src directory.

6
ast-passes/src/import_resolution/importer.rs
View File

@ -28,6 +28,9 @@ impl Importer {
where
T: ImportResolver,
{
let mut ast = program.clone();
ast.imports.extend(leo_stdlib::resolve_prelude_modules()?);
let mut imported_symbols: Vec<(Vec<String>, ImportSymbol, Span)> = vec![];
for import_statement in program.import_statements.iter() {
resolve_import_package(&mut imported_symbols, vec![], &import_statement.package_or_packages);
@ -53,8 +56,7 @@ impl Importer {
resolved_packages.insert(package.clone(), resolved_package);
}
let mut ast = program;
ast.imports = resolved_packages;
ast.imports.extend(resolved_packages);
Ok(Ast::new(ast))
}

33
ast-passes/src/import_resolution/resolver.rs
View File

@ -16,6 +16,7 @@
use leo_ast::Program;
use leo_errors::{Result, Span};
use leo_stdlib::resolve_stdlib_module;
use indexmap::IndexMap;
@ -43,8 +44,8 @@ impl<'a, T: ImportResolver> CoreImportResolver<'a, T> {
impl<'a, T: ImportResolver> ImportResolver for CoreImportResolver<'a, T> {
fn resolve_package(&mut self, package_segments: &[&str], span: &Span) -> Result<Option<Program>> {
if !package_segments.is_empty() && package_segments.get(0).unwrap() == &"core" {
Ok(resolve_core_module(&*package_segments[1..].join("."))?)
if !package_segments.is_empty() && package_segments.get(0).unwrap() == &"std" {
Ok(Some(resolve_stdlib_module(&*package_segments[1..].join("."))?))
} else {
self.inner.resolve_package(package_segments, span)
}
@ -60,31 +61,3 @@ impl ImportResolver for MockedImportResolver {
Ok(self.packages.get(&package_segments.join(".")).cloned())
}
}
// TODO: Remove this.
pub fn load_ast(content: &str) -> Result<Program> {
// Parses the Leo file and constructs a grammar ast.
Ok(leo_parser::parse_ast("input.leo", content)?.into_repr())
}
// TODO: We should merge this with core
// TODO: Make asg deep copy so we can cache resolved core modules
// TODO: Figure out how to do headers without bogus returns
pub fn resolve_core_module(module: &str) -> Result<Option<Program>> {
match module {
"unstable.blake2s" => {
let ast = load_ast(
r#"
circuit Blake2s {
function hash(seed: [u8; 32], message: [u8; 32]) -> [u8; 32] {
return [0; 32];
}
}
"#,
)?;
ast.set_core_mapping("blake2s");
Ok(Some(ast))
}
_ => Ok(None),
}
}

12
ast/src/lib.rs
View File

@ -89,18 +89,6 @@ impl Ast {
Self { ast: program }
}
/* /// Mutates the program ast by resolving the imports.
pub fn importer<T: ImportResolver>(&mut self, importer: T) -> Result<()> {
self.ast = ReconstructingDirector::new(Importer::new(importer)).reduce_program(self.as_repr())?;
Ok(())
}
/// Mutates the program ast by preforming canonicalization on it.
pub fn canonicalize(&mut self) -> Result<()> {
self.ast = ReconstructingDirector::new(Canonicalizer::default()).reduce_program(self.as_repr())?;
Ok(())
} */
/// Returns a reference to the inner program AST representation.
pub fn as_repr(&self) -> &Program {
&self.ast

4
ast/src/program.rs
View File

@ -88,9 +88,9 @@ impl Program {
}
}
pub fn set_core_mapping(&self, mapping: &str) {
pub fn set_core_mapping(&self, mapping: Option<&str>) {
for (_, circuit) in self.circuits.iter() {
circuit.core_mapping.replace(Some(mapping.to_string()));
circuit.core_mapping.replace(mapping.map(str::to_string));
}
}

11
compiler/src/compiler.rs
View File

@ -35,12 +35,13 @@ use snarkvm_r1cs::{ConstraintSynthesizer, ConstraintSystem, SynthesisError};
use sha2::{Digest, Sha256};
use std::{
collections::HashMap,
fs,
marker::PhantomData,
path::{Path, PathBuf},
};
use indexmap::IndexMap;
thread_local! {
static THREAD_GLOBAL_CONTEXT: AsgContext<'static> = {
let leaked = Box::leak(Box::new(leo_asg::new_alloc_context()));
@ -64,7 +65,7 @@ pub struct Compiler<'a, F: PrimeField, G: GroupType<F>> {
context: AsgContext<'a>,
asg: Option<AsgProgram<'a>>,
options: CompilerOptions,
imports_map: HashMap<String, String>,
imports_map: IndexMap<String, String>,
ast_snapshot_options: AstSnapshotOptions,
_engine: PhantomData<F>,
_group: PhantomData<G>,
@ -80,7 +81,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> Compiler<'a, F, G> {
output_directory: PathBuf,
context: AsgContext<'a>,
options: Option<CompilerOptions>,
imports_map: HashMap<String, String>,
imports_map: IndexMap<String, String>,
ast_snapshot_options: Option<AstSnapshotOptions>,
) -> Self {
Self {
@ -112,7 +113,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> Compiler<'a, F, G> {
output_directory: PathBuf,
context: AsgContext<'a>,
options: Option<CompilerOptions>,
imports_map: HashMap<String, String>,
imports_map: IndexMap<String, String>,
ast_snapshot_options: Option<AstSnapshotOptions>,
) -> Result<Self> {
let mut compiler = Self::new(
@ -153,7 +154,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> Compiler<'a, F, G> {
state_path: &Path,
context: AsgContext<'a>,
options: Option<CompilerOptions>,
imports_map: HashMap<String, String>,
imports_map: IndexMap<String, String>,
ast_snapshot_options: Option<AstSnapshotOptions>,
) -> Result<Self> {
let mut compiler = Self::new(

4
compiler/src/test.rs
View File

@ -15,7 +15,6 @@
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use std::{
collections::HashMap,
fs,
path::{Path, PathBuf},
};
@ -32,6 +31,7 @@ use serde_yaml::Value;
use snarkvm_curves::{bls12_377::Bls12_377, edwards_bls12::Fq};
use crate::{compiler::Compiler, targets::edwards_bls12::EdwardsGroupType, AstSnapshotOptions, Output};
use indexmap::IndexMap;
pub type EdwardsTestCompiler = Compiler<'static, Fq, EdwardsGroupType>;
// pub type EdwardsConstrainedValue = ConstrainedValue<'static, Fq, EdwardsGroupType>;
@ -53,7 +53,7 @@ fn new_compiler(path: PathBuf, theorem_options: Option<AstSnapshotOptions>) -> E
output_dir,
make_test_context(),
None,
HashMap::new(),
IndexMap::new(),
theorem_options,
)
}

16
docs/rfc/008-built-in-declarations.md
View File

@ -31,7 +31,7 @@ Leaving import declarations aside for the moment since they are "meta" in some s
(as they bring in names of entities declared elsewhere),
it may make sense for any of the four kinds of declarations above to have built-in instances, i.e., we could have some built-in functions, circuit types, global constants, and type aliases. These features are why this RFC talks of built-in declarations, more broadly than just built-in type aliases that inspired it.
The built-in status of the envisioned declarations will be done through explicitly declared core library files. Then these core library files must be explicitly imported. This way helps avoid unnecessary code bloat in the compilation, and any user asked for AST snapshots.
The built-in status of the envisioned declarations will be done through explicitly declared standard library(stdlib) files. Then these stdlib files must expressly be imported, except the files found in stdlib/prelude/*. The ones found in the prelude are features determined to be helpful enough in standard programs and are auto-imported.
## Drawbacks
@ -46,15 +46,7 @@ But it should not be much different from standard libraries/packages.
Some alternative approaches are:
1. Their names could be simply available in any program,
without any explicit declaration found anywhere for them.
2. They could be declared in some core library files explicitly
and be available in any program without explicitly importing them,
like `java.lang.String` in Java or `std::Option` in Rust.
1. Having all stdlib imports auto included.
2. Require that all stdlib imports are explicitly imported.
From a user's perspective, there is not a lot of difference between cases 1 and 2 above:
in both cases, the names are available; the only difference is that in case 2, the user can see the declaration somewhere.
Also, note that case 2 could be seen as having an implicit (i.e., built-in) import of the library/libraries in question. Again, imports are "meta" in this context, and what counts are the other kinds of declarations.
In cases 2 and the decided upon design choice, a related but somewhat independent issue is whether those declarations have Leo definitions or not. The Leo library already includes functions like BLAKE2s that are not defined in Leo but rather "natively" in Rust/R1CS though some of this may be subject to change for native definitions(see the separate RFC on those).
The differences between the two above approaches and the chosen one are just how many imports are imported explicitly.

18
errors/src/import/import_errors.rs
View File

@ -90,11 +90,27 @@ create_errors!(
help: None,
}
/// / For when the crate failed due to an IO error.
/// For when the crate failed due to an IO error.
@formatted
io_error {
args: (path: impl Display, error: impl ErrorArg),
msg: format!("cannot read imported file '{}': {:?}", path, error),
help: None,
}
/// For when the stdlib import file could not be found.
@backtraced
no_such_stdlib_file {
args: (import: impl Display),
msg: format!("failed to find the stdlib import file `{}`", import),
help: None,
}
/// For when the stdlib import file could not be read.
@backtraced
failed_to_read_stdlib_file {
args: (import: impl Display),
msg: format!("failed to read the stdlib import file `{}`", import),
help: None,
}
);

4
imports/Cargo.toml
View File

@ -29,10 +29,6 @@ version = "1.5.3"
path = "../errors"
version = "1.5.3"
[dependencies.leo-asg]
path = "../asg"
version = "1.5.3"
[dependencies.leo-parser]
path = "../parser"
version = "1.5.3"

10
imports/src/parser/import_parser.rs
View File

@ -19,7 +19,7 @@ use leo_ast_passes::ImportResolver;
use leo_errors::{ImportError, LeoError, Result, Span};
use indexmap::{IndexMap, IndexSet};
use std::{collections::HashMap, path::PathBuf};
use std::path::PathBuf;
/// Stores imported packages.
///
@ -30,11 +30,11 @@ pub struct ImportParser {
program_path: PathBuf,
partial_imports: IndexSet<String>,
imports: IndexMap<String, Program>,
pub imports_map: HashMap<String, String>,
pub imports_map: IndexMap<String, String>,
}
impl ImportParser {
pub fn new(program_path: PathBuf, imports_map: HashMap<String, String>) -> Self {
pub fn new(program_path: PathBuf, imports_map: IndexMap<String, String>) -> Self {
ImportParser {
program_path,
partial_imports: Default::default(),
@ -50,17 +50,21 @@ impl ImportResolver for ImportParser {
if self.partial_imports.contains(&full_path) {
return Err(ImportError::recursive_imports(full_path, span).into());
}
if let Some(program) = self.imports.get(&full_path) {
return Ok(Some(program.clone()));
}
let path = self.program_path.clone();
self.partial_imports.insert(full_path.clone());
let mut imports = self.clone(); // Self::default() was previously
let program = imports
.parse_package(path, package_segments, span)
.map_err(|x| -> LeoError { x })?;
self.partial_imports.remove(&full_path);
self.imports.insert(full_path, program.clone());
Ok(Some(program))
}
}

4
imports/src/parser/parse_package.rs
View File

@ -51,9 +51,9 @@ impl ImportParser {
let package_name = segments[0];
// Fetch a core package
let core_package = package_name.eq("core");
let core_package = package_name.eq("std");
if core_package {
panic!("attempted to import core package from filesystem");
panic!("attempted to import std package from filesystem");
}
// Trim path if importing from another file

3
leo/commands/test.rs
View File

@ -27,6 +27,7 @@ use leo_package::{
source::{MainFile, MAIN_FILENAME, SOURCE_DIRECTORY_NAME},
};
use indexmap::IndexMap;
use snarkvm_curves::edwards_bls12::Fq;
use std::{convert::TryFrom, path::PathBuf, time::Instant};
use structopt::StructOpt;
@ -109,7 +110,7 @@ impl Command for Test {
output_directory.clone(),
thread_leaked_context(),
Some(self.compiler_options.clone().into()),
std::collections::HashMap::new(),
IndexMap::new(),
Some(self.compiler_options.clone().into()),
)?;

7
package/src/root/lock_file.rs
View File

@ -21,7 +21,6 @@ use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use std::{
borrow::Cow,
collections::HashMap,
convert::TryFrom,
fmt::{self, Display},
fs::File,
@ -74,11 +73,11 @@ impl LockFile {
Ok(toml::to_string(self).map_err(PackageError::failed_to_serialize_lock_file)?)
}
/// Form a HashMap of kind:
/// Form a IndexMap of kind:
/// ``` imported_name => package_name ```
/// for all imported packages.
pub fn to_import_map(&self) -> HashMap<String, String> {
let mut result = HashMap::new();
pub fn to_import_map(&self) -> IndexMap<String, String> {
let mut result = IndexMap::new();
for package in self.package.iter() {
match &package.import_name {
Some(name) => result.insert(name.clone(), package.to_string()),

1
parser/src/tokenizer/lexer.rs
View File

@ -516,7 +516,6 @@ impl Token {
"Self" => Token::BigSelf,
"self" => Token::LittleSelf,
"static" => Token::Static,
"string" => Token::String,
"true" => Token::True,
"type" => Token::Type,
"u8" => Token::U8,

3
parser/src/tokenizer/token.rs
View File

@ -137,7 +137,6 @@ pub enum Token {
Mut,
Return,
Static,
String,
Type,
// Not yet in ABNF
// BitAnd,
@ -192,7 +191,6 @@ pub const KEYWORD_TOKENS: &[Token] = &[
Token::BigSelf,
Token::LittleSelf,
Token::Static,
Token::String,
Token::True,
Token::Type,
Token::U8,
@ -305,7 +303,6 @@ impl fmt::Display for Token {
Mut => write!(f, "mut"),
Return => write!(f, "return"),
Static => write!(f, "static"),
String => write!(f, "string"),
Type => write!(f, "type"),
Eof => write!(f, ""),
// BitAnd => write!(f, "&"),

37
stdlib/Cargo.toml Normal file
View File

@ -0,0 +1,37 @@
[package]
name = "leo-stdlib"
version = "1.5.3"
authors = [ "The Aleo Team <hello@aleo.org>" ]
description = "The Leo programming language"
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"
[lib]
path = "src/lib.rs"
[dependencies]
indexmap = "1.7.0"
include_dir = "0.6.1"
[dependencies.leo-ast]
path = "../ast"
version = "1.5.3"
[dependencies.leo-errors]
path = "../errors"
version = "1.5.3"
[dependencies.leo-parser]
path = "../parser"
version = "1.5.3"

596
stdlib/LICENSE.md Normal file
View File

@ -0,0 +1,596 @@
GNU General Public License
==========================
Version 3, 29 June 2007
Copyright © 2007 Free Software Foundation, Inc. &lt;<https://fsf.org/>&gt;
Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.
## Preamble
The GNU General Public License is a free, copyleft license for software and other
kinds of works.
The licenses for most software and other practical works are designed to take away
your freedom to share and change the works. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change all versions of a
program--to make sure it remains free software for all its users. We, the Free
Software Foundation, use the GNU General Public License for most of our software; it
applies also to any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not price. Our General
Public Licenses are designed to make sure that you have the freedom to distribute
copies of free software (and charge for them if you wish), that you receive source
code or can get it if you want it, that you can change the software or use pieces of
it in new free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you these rights or
asking you to surrender the rights. Therefore, you have certain responsibilities if
you distribute copies of the software, or if you modify it: responsibilities to
respect the freedom of others.
For example, if you distribute copies of such a program, whether gratis or for a fee,
you must pass on to the recipients the same freedoms that you received. You must make
sure that they, too, receive or can get the source code. And you must show them these
terms so they know their rights.
Developers that use the GNU GPL protect your rights with two steps: **(1)** assert
copyright on the software, and **(2)** offer you this License giving you legal permission
to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains that there is
no warranty for this free software. For both users' and authors' sake, the GPL
requires that modified versions be marked as changed, so that their problems will not
be attributed erroneously to authors of previous versions.
Some devices are designed to deny users access to install or run modified versions of
the software inside them, although the manufacturer can do so. This is fundamentally
incompatible with the aim of protecting users' freedom to change the software. The
systematic pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we have designed
this version of the GPL to prohibit the practice for those products. If such problems
arise substantially in other domains, we stand ready to extend this provision to
those domains in future versions of the GPL, as needed to protect the freedom of
users.
Finally, every program is threatened constantly by software patents. States should
not allow patents to restrict development and use of software on general-purpose
computers, but in those that do, we wish to avoid the special danger that patents
applied to a free program could make it effectively proprietary. To prevent this, the
GPL assures that patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and modification follow.
## TERMS AND CONDITIONS
### 0. Definitions
“This License” refers to version 3 of the GNU General Public License.
“Copyright” also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
“The Program” refers to any copyrightable work licensed under this
License. Each licensee is addressed as “you”. “Licensees” and
“recipients” may be individuals or organizations.
To “modify” a work means to copy from or adapt all or part of the work in
a fashion requiring copyright permission, other than the making of an exact copy. The
resulting work is called a “modified version” of the earlier work or a
work “based on” the earlier work.
A “covered work” means either the unmodified Program or a work based on
the Program.
To “propagate” a work means to do anything with it that, without
permission, would make you directly or secondarily liable for infringement under
applicable copyright law, except executing it on a computer or modifying a private
copy. Propagation includes copying, distribution (with or without modification),
making available to the public, and in some countries other activities as well.
To “convey” a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through a computer
network, with no transfer of a copy, is not conveying.
An interactive user interface displays “Appropriate Legal Notices” to the
extent that it includes a convenient and prominently visible feature that **(1)**
displays an appropriate copyright notice, and **(2)** tells the user that there is no
warranty for the work (except to the extent that warranties are provided), that
licensees may convey the work under this License, and how to view a copy of this
License. If the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
### 1. Source Code
The “source code” for a work means the preferred form of the work for
making modifications to it. “Object code” means any non-source form of a
work.
A “Standard Interface” means an interface that either is an official
standard defined by a recognized standards body, or, in the case of interfaces
specified for a particular programming language, one that is widely used among
developers working in that language.
The “System Libraries” of an executable work include anything, other than
the work as a whole, that **(a)** is included in the normal form of packaging a Major
Component, but which is not part of that Major Component, and **(b)** serves only to
enable use of the work with that Major Component, or to implement a Standard
Interface for which an implementation is available to the public in source code form.
A “Major Component”, in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system (if any) on which
the executable work runs, or a compiler used to produce the work, or an object code
interpreter used to run it.
The “Corresponding Source” for a work in object code form means all the
source code needed to generate, install, and (for an executable work) run the object
code and to modify the work, including scripts to control those activities. However,
it does not include the work's System Libraries, or general-purpose tools or
generally available free programs which are used unmodified in performing those
activities but which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for the work, and
the source code for shared libraries and dynamically linked subprograms that the work
is specifically designed to require, such as by intimate data communication or
control flow between those subprograms and other parts of the work.
The Corresponding Source need not include anything that users can regenerate
automatically from other parts of the Corresponding Source.
The Corresponding Source for a work in source code form is that same work.
### 2. Basic Permissions
All rights granted under this License are granted for the term of copyright on the
Program, and are irrevocable provided the stated conditions are met. This License
explicitly affirms your unlimited permission to run the unmodified Program. The
output from running a covered work is covered by this License only if the output,
given its content, constitutes a covered work. This License acknowledges your rights
of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not convey, without
conditions so long as your license otherwise remains in force. You may convey covered
works to others for the sole purpose of having them make modifications exclusively
for you, or provide you with facilities for running those works, provided that you
comply with the terms of this License in conveying all material for which you do not
control copyright. Those thus making or running the covered works for you must do so
exclusively on your behalf, under your direction and control, on terms that prohibit
them from making any copies of your copyrighted material outside their relationship
with you.
Conveying under any other circumstances is permitted solely under the conditions
stated below. Sublicensing is not allowed; section 10 makes it unnecessary.
### 3. Protecting Users' Legal Rights From Anti-Circumvention Law
No covered work shall be deemed part of an effective technological measure under any
applicable law fulfilling obligations under article 11 of the WIPO copyright treaty
adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention
of such measures.
When you convey a covered work, you waive any legal power to forbid circumvention of
technological measures to the extent such circumvention is effected by exercising
rights under this License with respect to the covered work, and you disclaim any
intention to limit operation or modification of the work as a means of enforcing,
against the work's users, your or third parties' legal rights to forbid circumvention
of technological measures.
### 4. Conveying Verbatim Copies
You may convey verbatim copies of the Program's source code as you receive it, in any
medium, provided that you conspicuously and appropriately publish on each copy an
appropriate copyright notice; keep intact all notices stating that this License and
any non-permissive terms added in accord with section 7 apply to the code; keep
intact all notices of the absence of any warranty; and give all recipients a copy of
this License along with the Program.
You may charge any price or no price for each copy that you convey, and you may offer
support or warranty protection for a fee.
### 5. Conveying Modified Source Versions
You may convey a work based on the Program, or the modifications to produce it from
the Program, in the form of source code under the terms of section 4, provided that
you also meet all of these conditions:
* **a)** The work must carry prominent notices stating that you modified it, and giving a
relevant date.
* **b)** The work must carry prominent notices stating that it is released under this
License and any conditions added under section 7. This requirement modifies the
requirement in section 4 to “keep intact all notices”.
* **c)** You must license the entire work, as a whole, under this License to anyone who
comes into possession of a copy. This License will therefore apply, along with any
applicable section 7 additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no permission to license the
work in any other way, but it does not invalidate such permission if you have
separately received it.
* **d)** If the work has interactive user interfaces, each must display Appropriate Legal
Notices; however, if the Program has interactive interfaces that do not display
Appropriate Legal Notices, your work need not make them do so.
A compilation of a covered work with other separate and independent works, which are
not by their nature extensions of the covered work, and which are not combined with
it such as to form a larger program, in or on a volume of a storage or distribution
medium, is called an “aggregate” if the compilation and its resulting
copyright are not used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work in an aggregate
does not cause this License to apply to the other parts of the aggregate.
### 6. Conveying Non-Source Forms
You may convey a covered work in object code form under the terms of sections 4 and
5, provided that you also convey the machine-readable Corresponding Source under the
terms of this License, in one of these ways:
* **a)** Convey the object code in, or embodied in, a physical product (including a
physical distribution medium), accompanied by the Corresponding Source fixed on a
durable physical medium customarily used for software interchange.
* **b)** Convey the object code in, or embodied in, a physical product (including a
physical distribution medium), accompanied by a written offer, valid for at least
three years and valid for as long as you offer spare parts or customer support for
that product model, to give anyone who possesses the object code either **(1)** a copy of
the Corresponding Source for all the software in the product that is covered by this
License, on a durable physical medium customarily used for software interchange, for
a price no more than your reasonable cost of physically performing this conveying of
source, or **(2)** access to copy the Corresponding Source from a network server at no
charge.
* **c)** Convey individual copies of the object code with a copy of the written offer to
provide the Corresponding Source. This alternative is allowed only occasionally and
noncommercially, and only if you received the object code with such an offer, in
accord with subsection 6b.
* **d)** Convey the object code by offering access from a designated place (gratis or for
a charge), and offer equivalent access to the Corresponding Source in the same way
through the same place at no further charge. You need not require recipients to copy
the Corresponding Source along with the object code. If the place to copy the object
code is a network server, the Corresponding Source may be on a different server
(operated by you or a third party) that supports equivalent copying facilities,
provided you maintain clear directions next to the object code saying where to find
the Corresponding Source. Regardless of what server hosts the Corresponding Source,
you remain obligated to ensure that it is available for as long as needed to satisfy
these requirements.
* **e)** Convey the object code using peer-to-peer transmission, provided you inform
other peers where the object code and Corresponding Source of the work are being
offered to the general public at no charge under subsection 6d.
A separable portion of the object code, whose source code is excluded from the
Corresponding Source as a System Library, need not be included in conveying the
object code work.
A “User Product” is either **(1)** a “consumer product”, which
means any tangible personal property which is normally used for personal, family, or
household purposes, or **(2)** anything designed or sold for incorporation into a
dwelling. In determining whether a product is a consumer product, doubtful cases
shall be resolved in favor of coverage. For a particular product received by a
particular user, “normally used” refers to a typical or common use of
that class of product, regardless of the status of the particular user or of the way
in which the particular user actually uses, or expects or is expected to use, the
product. A product is a consumer product regardless of whether the product has
substantial commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
“Installation Information” for a User Product means any methods,
procedures, authorization keys, or other information required to install and execute
modified versions of a covered work in that User Product from a modified version of
its Corresponding Source. The information must suffice to ensure that the continued
functioning of the modified object code is in no case prevented or interfered with
solely because modification has been made.
If you convey an object code work under this section in, or with, or specifically for
use in, a User Product, and the conveying occurs as part of a transaction in which
the right of possession and use of the User Product is transferred to the recipient
in perpetuity or for a fixed term (regardless of how the transaction is
characterized), the Corresponding Source conveyed under this section must be
accompanied by the Installation Information. But this requirement does not apply if
neither you nor any third party retains the ability to install modified object code
on the User Product (for example, the work has been installed in ROM).
The requirement to provide Installation Information does not include a requirement to
continue to provide support service, warranty, or updates for a work that has been
modified or installed by the recipient, or for the User Product in which it has been
modified or installed. Access to a network may be denied when the modification itself
materially and adversely affects the operation of the network or violates the rules
and protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided, in accord with
this section must be in a format that is publicly documented (and with an
implementation available to the public in source code form), and must require no
special password or key for unpacking, reading or copying.
### 7. Additional Terms
“Additional permissions” are terms that supplement the terms of this
License by making exceptions from one or more of its conditions. Additional
permissions that are applicable to the entire Program shall be treated as though they
were included in this License, to the extent that they are valid under applicable
law. If additional permissions apply only to part of the Program, that part may be
used separately under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option remove any
additional permissions from that copy, or from any part of it. (Additional
permissions may be written to require their own removal in certain cases when you
modify the work.) You may place additional permissions on material, added by you to a
covered work, for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you add to a
covered work, you may (if authorized by the copyright holders of that material)
supplement the terms of this License with terms:
* **a)** Disclaiming warranty or limiting liability differently from the terms of
sections 15 and 16 of this License; or
* **b)** Requiring preservation of specified reasonable legal notices or author
attributions in that material or in the Appropriate Legal Notices displayed by works
containing it; or
* **c)** Prohibiting misrepresentation of the origin of that material, or requiring that
modified versions of such material be marked in reasonable ways as different from the
original version; or
* **d)** Limiting the use for publicity purposes of names of licensors or authors of the
material; or
* **e)** Declining to grant rights under trademark law for use of some trade names,
trademarks, or service marks; or
* **f)** Requiring indemnification of licensors and authors of that material by anyone
who conveys the material (or modified versions of it) with contractual assumptions of
liability to the recipient, for any liability that these contractual assumptions
directly impose on those licensors and authors.
All other non-permissive additional terms are considered “further
restrictions” within the meaning of section 10. If the Program as you received
it, or any part of it, contains a notice stating that it is governed by this License
along with a term that is a further restriction, you may remove that term. If a
license document contains a further restriction but permits relicensing or conveying
under this License, you may add to a covered work material governed by the terms of
that license document, provided that the further restriction does not survive such
relicensing or conveying.
If you add terms to a covered work in accord with this section, you must place, in
the relevant source files, a statement of the additional terms that apply to those
files, or a notice indicating where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the form of a
separately written license, or stated as exceptions; the above requirements apply
either way.
### 8. Termination
You may not propagate or modify a covered work except as expressly provided under
this License. Any attempt otherwise to propagate or modify it is void, and will
automatically terminate your rights under this License (including any patent licenses
granted under the third paragraph of section 11).
However, if you cease all violation of this License, then your license from a
particular copyright holder is reinstated **(a)** provisionally, unless and until the
copyright holder explicitly and finally terminates your license, and **(b)** permanently,
if the copyright holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is reinstated permanently
if the copyright holder notifies you of the violation by some reasonable means, this
is the first time you have received notice of violation of this License (for any
work) from that copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the licenses of
parties who have received copies or rights from you under this License. If your
rights have been terminated and not permanently reinstated, you do not qualify to
receive new licenses for the same material under section 10.
### 9. Acceptance Not Required for Having Copies
You are not required to accept this License in order to receive or run a copy of the
Program. Ancillary propagation of a covered work occurring solely as a consequence of
using peer-to-peer transmission to receive a copy likewise does not require
acceptance. However, nothing other than this License grants you permission to
propagate or modify any covered work. These actions infringe copyright if you do not
accept this License. Therefore, by modifying or propagating a covered work, you
indicate your acceptance of this License to do so.
### 10. Automatic Licensing of Downstream Recipients
Each time you convey a covered work, the recipient automatically receives a license
from the original licensors, to run, modify and propagate that work, subject to this
License. You are not responsible for enforcing compliance by third parties with this
License.
An “entity transaction” is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an organization, or
merging organizations. If propagation of a covered work results from an entity
transaction, each party to that transaction who receives a copy of the work also
receives whatever licenses to the work the party's predecessor in interest had or
could give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if the predecessor
has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the rights granted or
affirmed under this License. For example, you may not impose a license fee, royalty,
or other charge for exercise of rights granted under this License, and you may not
initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging
that any patent claim is infringed by making, using, selling, offering for sale, or
importing the Program or any portion of it.
### 11. Patents
A “contributor” is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The work thus
licensed is called the contributor's “contributor version”.
A contributor's “essential patent claims” are all patent claims owned or
controlled by the contributor, whether already acquired or hereafter acquired, that
would be infringed by some manner, permitted by this License, of making, using, or
selling its contributor version, but do not include claims that would be infringed
only as a consequence of further modification of the contributor version. For
purposes of this definition, “control” includes the right to grant patent
sublicenses in a manner consistent with the requirements of this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free patent license
under the contributor's essential patent claims, to make, use, sell, offer for sale,
import and otherwise run, modify and propagate the contents of its contributor
version.
In the following three paragraphs, a “patent license” is any express
agreement or commitment, however denominated, not to enforce a patent (such as an
express permission to practice a patent or covenant not to sue for patent
infringement). To “grant” such a patent license to a party means to make
such an agreement or commitment not to enforce a patent against the party.
If you convey a covered work, knowingly relying on a patent license, and the
Corresponding Source of the work is not available for anyone to copy, free of charge
and under the terms of this License, through a publicly available network server or
other readily accessible means, then you must either **(1)** cause the Corresponding
Source to be so available, or **(2)** arrange to deprive yourself of the benefit of the
patent license for this particular work, or **(3)** arrange, in a manner consistent with
the requirements of this License, to extend the patent license to downstream
recipients. “Knowingly relying” means you have actual knowledge that, but
for the patent license, your conveying the covered work in a country, or your
recipient's use of the covered work in a country, would infringe one or more
identifiable patents in that country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or arrangement, you
convey, or propagate by procuring conveyance of, a covered work, and grant a patent
license to some of the parties receiving the covered work authorizing them to use,
propagate, modify or convey a specific copy of the covered work, then the patent
license you grant is automatically extended to all recipients of the covered work and
works based on it.
A patent license is “discriminatory” if it does not include within the
scope of its coverage, prohibits the exercise of, or is conditioned on the
non-exercise of one or more of the rights that are specifically granted under this
License. You may not convey a covered work if you are a party to an arrangement with
a third party that is in the business of distributing software, under which you make
payment to the third party based on the extent of your activity of conveying the
work, and under which the third party grants, to any of the parties who would receive
the covered work from you, a discriminatory patent license **(a)** in connection with
copies of the covered work conveyed by you (or copies made from those copies), or **(b)**
primarily for and in connection with specific products or compilations that contain
the covered work, unless you entered into that arrangement, or that patent license
was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting any implied
license or other defenses to infringement that may otherwise be available to you
under applicable patent law.
### 12. No Surrender of Others' Freedom
If conditions are imposed on you (whether by court order, agreement or otherwise)
that contradict the conditions of this License, they do not excuse you from the
conditions of this License. If you cannot convey a covered work so as to satisfy
simultaneously your obligations under this License and any other pertinent
obligations, then as a consequence you may not convey it at all. For example, if you
agree to terms that obligate you to collect a royalty for further conveying from
those to whom you convey the Program, the only way you could satisfy both those terms
and this License would be to refrain entirely from conveying the Program.
### 13. Use with the GNU Affero General Public License
Notwithstanding any other provision of this License, you have permission to link or
combine any covered work with a work licensed under version 3 of the GNU Affero
General Public License into a single combined work, and to convey the resulting work.
The terms of this License will continue to apply to the part which is the covered
work, but the special requirements of the GNU Affero General Public License, section
13, concerning interaction through a network will apply to the combination as such.
### 14. Revised Versions of this License
The Free Software Foundation may publish revised and/or new versions of the GNU
General Public License from time to time. Such new versions will be similar in spirit
to the present version, but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Program specifies that
a certain numbered version of the GNU General Public License “or any later
version” applies to it, you have the option of following the terms and
conditions either of that numbered version or of any later version published by the
Free Software Foundation. If the Program does not specify a version number of the GNU
General Public License, you may choose any version ever published by the Free
Software Foundation.
If the Program specifies that a proxy can decide which future versions of the GNU
General Public License can be used, that proxy's public statement of acceptance of a
version permanently authorizes you to choose that version for the Program.
Later license versions may give you additional or different permissions. However, no
additional obligations are imposed on any author or copyright holder as a result of
your choosing to follow a later version.
### 15. Disclaimer of Warranty
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER
EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE
QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
### 16. Limitation of Liability
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY
COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS
PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE
OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
### 17. Interpretation of Sections 15 and 16
If the disclaimer of warranty and limitation of liability provided above cannot be
given local legal effect according to their terms, reviewing courts shall apply local
law that most closely approximates an absolute waiver of all civil liability in
connection with the Program, unless a warranty or assumption of liability accompanies
a copy of the Program in return for a fee.
_END OF TERMS AND CONDITIONS_
## How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest possible use to
the public, the best way to achieve this is to make it free software which everyone
can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest to attach them
to the start of each source file to most effectively state the exclusion of warranty;
and each file should have at least the “copyright” line and a pointer to
where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program 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.
This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short notice like this
when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type 'show c' for details.
The hypothetical commands `show w` and `show c` should show the appropriate parts of
the General Public License. Of course, your program's commands might be different;
for a GUI interface, you would use an “about box”.
You should also get your employer (if you work as a programmer) or school, if any, to
sign a “copyright disclaimer” for the program, if necessary. For more
information on this, and how to apply and follow the GNU GPL, see
&lt;<http://www.gnu.org/licenses/>&gt;.
The GNU General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may consider it
more useful to permit linking proprietary applications with the library. If this is
what you want to do, use the GNU Lesser General Public License instead of this
License. But first, please read
&lt;<http://www.gnu.org/philosophy/why-not-lgpl.html>&gt;.

29
stdlib/README.md Normal file
View File

@ -0,0 +1,29 @@
# leo-stdlib
[![Crates.io](https://img.shields.io/crates/v/leo-ast.svg?color=neon)](https://crates.io/crates/leo-ast)
[![Authors](https://img.shields.io/badge/authors-Aleo-orange.svg)](../AUTHORS)
[![License](https://img.shields.io/badge/License-GPLv3-blue.svg)](./LICENSE.md)
This directory includes the standard library for Leo.
## Usage
The src directory is the Rust code that makes the Leo folders and files statically built into the compiler. So any added Leo folders and files under the `stdlib` directory will be automatically included at compile time.
See the [Structure](#structure) section for more info.
## Structure
The structure for this repository is a bit special.
One important thing to note is the prelude directory. Any Leo files defined in this directory will have all importable objects automatically imported to every Leo program. For example, the following program is valid without any imports:
```typescript
function main() {
let s: string = "Hello, string type alias!";
}
```
The above type alias is auto imported from `stdlib/prelude/string.leo`.
The other directories must have explicit imports. For example, the unstable Blake2s can be imported with `import std.unstable.blake2s.Blake2s`. Which imports the `Blake2s` circuit defined in `stdlib/unstable/blake2s.leo`.

1
stdlib/prelude/string.leo Normal file
View File

@ -0,0 +1 @@
type string = [char; _];

76
stdlib/src/lib.rs Normal file
View File

@ -0,0 +1,76 @@
// 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/>.
#![doc = include_str!("../README.md")]
use leo_ast::Program;
use leo_errors::{ImportError, Result};
#[macro_use]
extern crate include_dir;
use include_dir::Dir;
use indexmap::IndexMap;
static STDLIB: Dir = include_dir!(".");
fn resolve_file(file: &str, mapping: Option<&str>) -> Result<Program> {
let resolved = STDLIB
.get_file(&file)
.ok_or_else(|| ImportError::no_such_stdlib_file(file))?
.contents_utf8()
.ok_or_else(|| ImportError::failed_to_read_stdlib_file(file))?;
let ast = leo_parser::parse_ast(&file, resolved)?.into_repr();
ast.set_core_mapping(mapping);
Ok(ast)
}
pub fn resolve_prelude_modules() -> Result<IndexMap<Vec<String>, Program>> {
let mut preludes: IndexMap<Vec<String>, Program> = IndexMap::new();
for module in STDLIB.find("prelude/*.leo").unwrap() {
// If on windows repalce \\ with / as all paths are stored in unix style.
let path = module.path().to_str().unwrap_or("").replace("\\", "/");
let program = resolve_file(&path, None)?;
let removed_extension = path.replace(".leo", "");
let mut parts: Vec<String> = vec![String::from("std")];
parts.append(
&mut removed_extension
.split('/')
.map(str::to_string)
.collect::<Vec<String>>(),
);
preludes.insert(parts, program);
}
Ok(preludes)
}
pub fn resolve_stdlib_module(module: &str) -> Result<Program> {
let mut file_path = module.replace(".", "/");
file_path.push_str(".leo");
let mapping = if module == "unstable.blake2s" {
Some("blake2s")
} else {
None
};
resolve_file(&file_path, mapping)
}

5
stdlib/unstable/blake2s.leo Normal file
View File

@ -0,0 +1,5 @@
circuit Blake2s {
function hash(seed: [u8; 32], message: [u8; 32]) -> [u8; 32] {
return [0; 32];
}
}

8
tests/compiler/core/core_circuit_invalid.leo
View File

@ -1,8 +0,0 @@
/*
namespace: Compile
expectation: Fail
*/
import core.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package
function main() {}

8
tests/compiler/core/core_circuit_star_fail.leo
View File

@ -1,8 +0,0 @@
/*
namespace: Compile
expectation: Fail
*/
import core.*; // You cannot import all dependencies from core at once
function main() {}

8
tests/compiler/core/core_unstable_package_invalid.leo
View File

@ -1,8 +0,0 @@
/*
namespace: Compile
expectation: Fail
*/
import core.unstable.bad_circuit; // `bad_circuit` is not a core unstable package
function main() {}

4
tests/compiler/definition/out_of_order_with_import.leo
View File

@ -11,7 +11,7 @@ function main(y: bool) -> bool {
return y == true;
}
// use core import to test import order
import core.unstable.blake2s.Blake2s;
// use std import to test import order
import std.unstable.blake2s.Blake2s;
circuit Foo {}

2
tests/compiler/core/blake2s.leo → tests/compiler/stdlib/blake2s.leo
View File

@ -3,7 +3,7 @@
// input_files:
// - input/dummy.in
import core.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package
import std.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package
function main() -> bool {
return false;

8
tests/compiler/stdlib/core_circuit_invalid.leo Normal file
View File

@ -0,0 +1,8 @@
/*
namespace: Compile
expectation: Fail
*/
import std.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package
function main() {}

8
tests/compiler/stdlib/core_circuit_star_fail.leo Normal file
View File

@ -0,0 +1,8 @@
/*
namespace: Compile
expectation: Fail
*/
import std.*; // You cannot import all dependencies from core at once
function main() {}

2
tests/compiler/core/core_package_invalid.leo → tests/compiler/stdlib/core_package_invalid.leo
View File

@ -3,6 +3,6 @@ namespace: Compile
expectation: Fail
*/
import core.bad_circuit; // `bad_circuit` is not a core package
import std.bad_circuit; // `bad_circuit` is not a core package
function main() {}

8
tests/compiler/stdlib/core_unstable_package_invalid.leo Normal file
View File

@ -0,0 +1,8 @@
/*
namespace: Compile
expectation: Fail
*/
import std.unstable.bad_circuit; // `bad_circuit` is not a core unstable package
function main() {}

0
tests/compiler/core/packages/unstable/_blake2s/arguments_length_fail.leo → tests/compiler/stdlib/packages/unstable/_blake2s/arguments_length_fail.leo
View File

0
tests/compiler/core/packages/unstable/_blake2s/arguments_type_fail.leo → tests/compiler/stdlib/packages/unstable/_blake2s/arguments_type_fail.leo
View File

0
tests/compiler/core/packages/unstable/_blake2s/blake2s_input.leo → tests/compiler/stdlib/packages/unstable/_blake2s/blake2s_input.leo
View File

0
tests/compiler/core/packages/unstable/_blake2s/blake2s_random.leo → tests/compiler/stdlib/packages/unstable/_blake2s/blake2s_random.leo
View File

0
tests/compiler/core/packages/unstable/_blake2s/inputs/valid_input.in → tests/compiler/stdlib/packages/unstable/_blake2s/inputs/valid_input.in
View File

0
tests/compiler/core/packages/unstable/_blake2s/mod.rs → tests/compiler/stdlib/packages/unstable/_blake2s/mod.rs
View File

0
tests/compiler/core/packages/unstable/_blake2s/outputs/valid_output.out → tests/compiler/stdlib/packages/unstable/_blake2s/outputs/valid_output.out
View File

15
tests/compiler/stdlib/strings.leo Normal file
View File

@ -0,0 +1,15 @@
// namespace: Compile
// expectation: Pass
// inputs:
// - hello.in: |
// [main]
// hello: [char; 5] = "hello";
// [registers]
// r0: bool = true;
function main(hello: [char; 5]) -> bool {
let hello2: string = "hello";
return hello == hello2;
}

2
tests/compiler/core/unstable_blake2s.leo → tests/compiler/stdlib/unstable_blake2s.leo
View File

@ -8,7 +8,7 @@
// [registers]
// r0: [u8; 32] = [0; 32];
import core.unstable.blake2s.Blake2s;
import std.unstable.blake2s.Blake2s;
function main(message: [u8; 32]) -> [u8; 32] {
const seed: [u8; 32] = [1; 32];

6
tests/expectations/compiler/compiler/address/branch.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 32dcc6719d7d1214782cd1ffe02f067eec8adbf1f3820546e539887d4f1334c8
imports_resolved_ast: 32dcc6719d7d1214782cd1ffe02f067eec8adbf1f3820546e539887d4f1334c8
canonicalized_ast: 32dcc6719d7d1214782cd1ffe02f067eec8adbf1f3820546e539887d4f1334c8
type_inferenced_ast: 996f46f1dba11bdde037a8e033ca97870871eb89d4e3e402b59f99fcc0c35323
imports_resolved_ast: 4e707995ef2cb41edba1339c811ae476bf30a2f65bb09137372a2a0931285260
canonicalized_ast: 4e707995ef2cb41edba1339c811ae476bf30a2f65bb09137372a2a0931285260
type_inferenced_ast: e3d743b0cc61c5e785559f469d394ae364f0a338cff37974bfc926497013bdd1

6
tests/expectations/compiler/compiler/address/equal.leo.out
View File

@ -23,6 +23,6 @@ outputs:
type: bool
value: "false"
initial_ast: d9d5346dff8f825d58daabb3a4fe2fcd1471a3fb3c80e46e5583c4f6cdb12b2b
imports_resolved_ast: d9d5346dff8f825d58daabb3a4fe2fcd1471a3fb3c80e46e5583c4f6cdb12b2b
canonicalized_ast: d9d5346dff8f825d58daabb3a4fe2fcd1471a3fb3c80e46e5583c4f6cdb12b2b
type_inferenced_ast: 32a303da117b08aebfb74f7454cd80dfe28b07fd464a61b6d6a3ce23d451f135
imports_resolved_ast: e5e91879622f5e63f1b465a8d1d99b9ad10e128d3b04493def195d81e5c728f3
canonicalized_ast: e5e91879622f5e63f1b465a8d1d99b9ad10e128d3b04493def195d81e5c728f3
type_inferenced_ast: 436fd5fbf72020d63c2f462dd271dbeeca6161c68f625e53ab5f827cda3d3d3e

6
tests/expectations/compiler/compiler/address/index.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 9961e21337ff8eed0a27fff91fc442c2530a1bfaf80da6d497a93a371896b1f8
imports_resolved_ast: 9961e21337ff8eed0a27fff91fc442c2530a1bfaf80da6d497a93a371896b1f8
canonicalized_ast: 9961e21337ff8eed0a27fff91fc442c2530a1bfaf80da6d497a93a371896b1f8
type_inferenced_ast: cc47000b2cf462f5cb891467cc99f2d21c44ced2198e988dc3de59f166aa1603
imports_resolved_ast: 763fdfbdda86ca59a4e8c18f0e9e7f87516725d886468a7bf5b5d37bfde140f8
canonicalized_ast: 763fdfbdda86ca59a4e8c18f0e9e7f87516725d886468a7bf5b5d37bfde140f8
type_inferenced_ast: 6acc95039938704a57b102cb2b3e61cde8375cc1e7595394b759dfc23a4fbedb

6
tests/expectations/compiler/compiler/address/ternary.leo.out
View File

@ -23,6 +23,6 @@ outputs:
type: bool
value: "false"
initial_ast: 6f8e7a94ccb702790204360959a2673abf6b53027fccaaa9feed8a4e41ee05c1
imports_resolved_ast: 6f8e7a94ccb702790204360959a2673abf6b53027fccaaa9feed8a4e41ee05c1
canonicalized_ast: 6f8e7a94ccb702790204360959a2673abf6b53027fccaaa9feed8a4e41ee05c1
type_inferenced_ast: 91e597663c88fbfd0c6ff787d109f5a71d5357c44d5306f7149714cda86475ae
imports_resolved_ast: e3570e385d638499b9ce95f0266f87e1c5bd72f7ddcd2718fee3f8f7080cf218
canonicalized_ast: e3570e385d638499b9ce95f0266f87e1c5bd72f7ddcd2718fee3f8f7080cf218
type_inferenced_ast: c29bc0a2616f928552e44d4e46c363c5707b986737e825855fd0a6165bfa55f3

6
tests/expectations/compiler/compiler/aliases/arith.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 6349e2684562bad873bcf643e01eeb02039295bd41e2df77f1fefc7bb3f2d3bb
imports_resolved_ast: 6349e2684562bad873bcf643e01eeb02039295bd41e2df77f1fefc7bb3f2d3bb
canonicalized_ast: 6349e2684562bad873bcf643e01eeb02039295bd41e2df77f1fefc7bb3f2d3bb
type_inferenced_ast: 508686ddeb2f8fad60d9ad58639b5a761e6c5f5b61e105803eb8a98d8065a2ad
imports_resolved_ast: 2b00607e4a777539b2abb677ac95108208d03409adb6b672e00d26cada45b1e6
canonicalized_ast: 2b00607e4a777539b2abb677ac95108208d03409adb6b672e00d26cada45b1e6
type_inferenced_ast: f0a02b6b326925afb8b1f8fbdafb5686687e695eb4420010d2c8d1564ac0a7b2

6
tests/expectations/compiler/compiler/aliases/basic.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 9f78c996da10363fb594947ca29fef29e35a7032761ce87f69f3ae454650d47e
imports_resolved_ast: 9f78c996da10363fb594947ca29fef29e35a7032761ce87f69f3ae454650d47e
canonicalized_ast: 9f78c996da10363fb594947ca29fef29e35a7032761ce87f69f3ae454650d47e
type_inferenced_ast: 103314a18ce6036da1ab4cc32c025b694cf799492460ab9553dfbd5232544a89
imports_resolved_ast: 32e35e00fe92c3cd71959cacb44d76f19782e5fcdeb57b839f1ff6a37dee3964
canonicalized_ast: 32e35e00fe92c3cd71959cacb44d76f19782e5fcdeb57b839f1ff6a37dee3964
type_inferenced_ast: d6afa34bd1c84c58bb1920be76e893f16a0a7ba1a952493679d2e219b70ac13d

6
tests/expectations/compiler/compiler/aliases/circuit.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: ee817c17e6bef3b458e14d3a81c087ed6a75c4554bc70b62466e8d8e43ff1b5e
imports_resolved_ast: ee817c17e6bef3b458e14d3a81c087ed6a75c4554bc70b62466e8d8e43ff1b5e
canonicalized_ast: ee817c17e6bef3b458e14d3a81c087ed6a75c4554bc70b62466e8d8e43ff1b5e
type_inferenced_ast: b15c7e773ebb56e339f750401241e38aab4ab8950c20a70acc293afc1b91d917
imports_resolved_ast: 4c477f127d0f5044d37279a8892ad04dafccb200665044e341f74e2e10152de6
canonicalized_ast: 4c477f127d0f5044d37279a8892ad04dafccb200665044e341f74e2e10152de6
type_inferenced_ast: 9c27915c9e63f5a0a05ead01b6a1564c53956ecbc6e90cb7b33f074d423add24

6
tests/expectations/compiler/compiler/aliases/fn_return.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 8d5ed3110bc3a61ddee37408133fcc1f77209b65bb83d230729203009e093f40
imports_resolved_ast: 8d5ed3110bc3a61ddee37408133fcc1f77209b65bb83d230729203009e093f40
canonicalized_ast: 8d5ed3110bc3a61ddee37408133fcc1f77209b65bb83d230729203009e093f40
type_inferenced_ast: bc54ad21e90ab297b40ff570dfc379cbca61fdc9e20bd6899f4b964f726954b0
imports_resolved_ast: 3bf9b1a7fe682434578831c20f0ab67ef37aa3a069bc302a99bd8976678158c3
canonicalized_ast: 3bf9b1a7fe682434578831c20f0ab67ef37aa3a069bc302a99bd8976678158c3
type_inferenced_ast: 397cf0ec0e99c094c9d2aa4f1a67df6564a2f6ff5c9a2bd82b47fac583598dca

6
tests/expectations/compiler/compiler/aliases/shadowing_arg.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: f7b2eb89c51644dc8596988bcc66fbfe471489887c6f46b78ca417746c7ef442
imports_resolved_ast: f7b2eb89c51644dc8596988bcc66fbfe471489887c6f46b78ca417746c7ef442
canonicalized_ast: f7b2eb89c51644dc8596988bcc66fbfe471489887c6f46b78ca417746c7ef442
type_inferenced_ast: f24ef5063928ee7998b53e5e66064c56c01bd99d55b736309d3a1d11ff2fec05
imports_resolved_ast: 01a3839714be9b09a1ab61b19adde2a8f45ba6eeb0181f3f746dcf2646f73c7c
canonicalized_ast: 01a3839714be9b09a1ab61b19adde2a8f45ba6eeb0181f3f746dcf2646f73c7c
type_inferenced_ast: 4f5b9e0532f6476cb6a3f11c4c08d4c59b3e67db76f4358b77e77c6d8fdd8a22

6
tests/expectations/compiler/compiler/aliases/shadowing_var_allowed.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 66ead06ceac4fea6a24fe071a955986722a53975fa98d2ad2909a83fa8ba8525
imports_resolved_ast: 66ead06ceac4fea6a24fe071a955986722a53975fa98d2ad2909a83fa8ba8525
canonicalized_ast: 66ead06ceac4fea6a24fe071a955986722a53975fa98d2ad2909a83fa8ba8525
type_inferenced_ast: 1e73226b2cbbd5c7a36ffe70b778e0e544976d2e09a1f0ba3f2b486d1b604d58
imports_resolved_ast: 2f34d52f534da1c7ec6ebe99be8cec87483f1a73d4cfa9d1d70d40db6304922f
canonicalized_ast: 2f34d52f534da1c7ec6ebe99be8cec87483f1a73d4cfa9d1d70d40db6304922f
type_inferenced_ast: 26402d98870ae4395a8b7cacf9d25e9cc0920c42dbc7bf48c944ec220138289e

6
tests/expectations/compiler/compiler/array/complex_access.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 843884ddf198fe566cea0f8e84a2902f720d6211c9d8bad98299eea4da846870
imports_resolved_ast: 843884ddf198fe566cea0f8e84a2902f720d6211c9d8bad98299eea4da846870
canonicalized_ast: c30721e60523bc31af9a9bf342d9b89bf92a26e3886394cc0c1a574560715bdf
type_inferenced_ast: baed608da257be0625cd54a796c2f89e9aec8b1ff60f23c7657a0c4fc260e1d1
imports_resolved_ast: 984f2f99c58550a478b8abd5d9f84e88052dbf1ed92b79d1de2d6d251148ddd7
canonicalized_ast: 1dee4c73f9faa33e13c2b98aecba1ce88ab110fde39b7a573e06969f8dbf84d5
type_inferenced_ast: 3bb764584aaa81586edbf85ae1e7ae0774d2e03599c04279f8451205b71e16a4

6
tests/expectations/compiler/compiler/array/equal_initializer.leo.out
View File

@ -23,6 +23,6 @@ outputs:
type: bool
value: "false"
initial_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a
imports_resolved_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a
canonicalized_ast: ace5006c27d2e3784fb73d52adc641f6285a041452ba0d23de5983c5eede1139
type_inferenced_ast: 611bc2fab64e417c9cfad3c59ca333561b8167a6fc7be957d972d96125e040ba
imports_resolved_ast: eeccd5c884082a153d06ec18d0eefe48c7c10c7f8b2ca4eb8bf07c6135756892
canonicalized_ast: 2871e0b38129c9fe8ffb798df90cac534f0c43d2c4bd7b78575ed3e7756027dc
type_inferenced_ast: fdee9f43afe71741d8b1783392ce434f30f252d2602902dc964112949c772109

6
tests/expectations/compiler/compiler/array/equal_initializer_2.leo.out
View File

@ -23,6 +23,6 @@ outputs:
type: bool
value: "true"
initial_ast: 307b6817fa2a5005462686901129e97bf75c00bf14568fafbe1de2c8afc1804d
imports_resolved_ast: 307b6817fa2a5005462686901129e97bf75c00bf14568fafbe1de2c8afc1804d
canonicalized_ast: cbaa304ba210d8155762701d8e6a2ddca3eaffb008a813ed7a60db1fb0043f10
type_inferenced_ast: 47e371ce112ac17fd65bfd100d24829e8c4819e1f96cc715b8c6245f01d608bb
imports_resolved_ast: 82b0b35a7fdddad336498a8ed852d07f0baa33083ce2777b41ffc40a4e969e12
canonicalized_ast: 5cf7e51b880f36efee857debac30612d0f1dc8457529dec4693e1071d56858fe
type_inferenced_ast: 113469cf66301a79575823164b365ea8f8cf627df758c1454ff31f42b36ac35e

6
tests/expectations/compiler/compiler/array/input_nested_3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 6d5be1a3d383ecafa89b5327d3a4b9bce9a459f6c0241cb01f408566ec4a1cc4
imports_resolved_ast: 6d5be1a3d383ecafa89b5327d3a4b9bce9a459f6c0241cb01f408566ec4a1cc4
canonicalized_ast: eb64230be87deb03ac7f076961a82194a15afd964aa6966a10314b38def69684
type_inferenced_ast: e7985a24db781a3e42c9b2a67d1e8febc78fc2ad4e388a90207d00eb89734ffd
imports_resolved_ast: 1b2fa78c990dfcaaa8deffd18ce45ca76561da60d0dba1b3f7825f43ee0ac3ef
canonicalized_ast: 0a756dbc1859bfbdb6b98b587054bf548402da737df3b7e9c2318cb9bbcb4a67
type_inferenced_ast: 97199b96614f9e92928c536b34760c204383495ff1ea198a7593007de61619cc

6
tests/expectations/compiler/compiler/array/input_tuple_3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a
imports_resolved_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a
canonicalized_ast: ace5006c27d2e3784fb73d52adc641f6285a041452ba0d23de5983c5eede1139
type_inferenced_ast: 611bc2fab64e417c9cfad3c59ca333561b8167a6fc7be957d972d96125e040ba
imports_resolved_ast: eeccd5c884082a153d06ec18d0eefe48c7c10c7f8b2ca4eb8bf07c6135756892
canonicalized_ast: 2871e0b38129c9fe8ffb798df90cac534f0c43d2c4bd7b78575ed3e7756027dc
type_inferenced_ast: fdee9f43afe71741d8b1783392ce434f30f252d2602902dc964112949c772109

6
tests/expectations/compiler/compiler/array/multi_initializer.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 0724c81ae70c56ff047b5d28ef949b72c4b581ce0bb443957064efa1636a3cab
imports_resolved_ast: 0724c81ae70c56ff047b5d28ef949b72c4b581ce0bb443957064efa1636a3cab
canonicalized_ast: ed0b7200a455978fed9b1df0c9e3ab9bf4815d79048f28f4205c69b420ee02df
type_inferenced_ast: 1e5c78e15d8c9328190e95ccbc2e4e105d9ce430b98704a12472e2c3cc870526
imports_resolved_ast: c90904ba0845fa4b092f69fe81782438ecad5bb883c3fd30d3e5c3670e6a98c9
canonicalized_ast: 9cd79d308a80e2feafffc66139d517026b15e35b75c7d3eae49ade65bb405338
type_inferenced_ast: e4fe63ac330b3a7087740c70e01fd18002a310c7f637de76db62f7d43d2d3c5b

6
tests/expectations/compiler/compiler/array/nested.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 60d0b81c9f3631aca3c9607df74cfb8e4dbc0d387836398dea86f016fa4210fd
imports_resolved_ast: 60d0b81c9f3631aca3c9607df74cfb8e4dbc0d387836398dea86f016fa4210fd
canonicalized_ast: 6570de0e96b21780ed7793a860948b2c6ff7a92da7ce7f3dd7775ff30d70656f
type_inferenced_ast: ace51ab56a61b988bd2c3f65431e87234a96fa92554d36d4e83d7235832506f6
imports_resolved_ast: 6e9dfcccc07d698f3b825fe6920bc25f8b97a8fa37b248948fb6d8308d197ff0
canonicalized_ast: c2aaa302a5e85a3c369c4246cdfcf97c5644d0b2feb6ba164b63e2bba43959f7
type_inferenced_ast: 7beb03c5d82bd7fa0bbe81a92d730e2f2e8689ed183848f0225638b9a39fe6ca

6
tests/expectations/compiler/compiler/array/nested_3x2_value.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 754eca05d485d80c4b710db30efc66f91c0eafdc02c2707f854238863b6c6c02
imports_resolved_ast: 754eca05d485d80c4b710db30efc66f91c0eafdc02c2707f854238863b6c6c02
canonicalized_ast: e5554c42dc9a45ab57ea5ac28996969640fb6f8da1ad8db805f65f5d555c8cf4
type_inferenced_ast: aa30bccd05b7386ffb8a7df7cad89ec39117c6b5fc51a9e68624064832b4f225
imports_resolved_ast: 74c98b37113df6f99b4ec2dbddb0e7b44c2db43553a1c5dcd168ccff36c067ca
canonicalized_ast: a9bf64a55240d8dffde6ae374972edb8229c9284a50c49f7a8430aaf995e57dc
type_inferenced_ast: 5153c986fce08dc7e5d9d53769de974e358cc7c6b1883e70f4cd4b7c436e76e3

6
tests/expectations/compiler/compiler/array/registers.leo.out
View File

@ -23,6 +23,6 @@ outputs:
type: "[u8; 3]"
value: "\"123\""
initial_ast: 4e74124bc410534941ef9b79ffb64656d14e145b5a79fbd14419c1aef2f0ef69
imports_resolved_ast: 4e74124bc410534941ef9b79ffb64656d14e145b5a79fbd14419c1aef2f0ef69
canonicalized_ast: 4e74124bc410534941ef9b79ffb64656d14e145b5a79fbd14419c1aef2f0ef69
type_inferenced_ast: de80815f88fb65efa62ce7f5fa23c6fc4f1bbdf601954e94c1212c4eabbee1cb
imports_resolved_ast: db3d3efd3292a3bd16296822fbe5d0b51ccae3379d0307e8bb98b6ca062ea3cd
canonicalized_ast: db3d3efd3292a3bd16296822fbe5d0b51ccae3379d0307e8bb98b6ca062ea3cd
type_inferenced_ast: 81e91909dd86190f8bc2b3b0bcd949c78518b4540a7e8ed6d20ab541b8708345

6
tests/expectations/compiler/compiler/array/slice.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 0e4761ba1228f0a490b51ff2c31df33f623a08d32f62833d64859ca103689f4a
imports_resolved_ast: 0e4761ba1228f0a490b51ff2c31df33f623a08d32f62833d64859ca103689f4a
canonicalized_ast: 0e4761ba1228f0a490b51ff2c31df33f623a08d32f62833d64859ca103689f4a
type_inferenced_ast: 1494bb64c16ec2dc03bfb2e37b89f93e02a70860ced1ce0b42b5ee5ead31b0d5
imports_resolved_ast: 1b2ba53d65d93c8ba810f1b2c241773e9d901aa987885ccd7db7b7ca606c5dc1
canonicalized_ast: 1b2ba53d65d93c8ba810f1b2c241773e9d901aa987885ccd7db7b7ca606c5dc1
type_inferenced_ast: 886c9c3d37af3f6d951268eaeddc5c68e1674237dbaf11eb7c76dfdb23e5ece3

6
tests/expectations/compiler/compiler/array/slice_lower.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 1bf9b30e052d9ecc042a0b20bbc195a98d463ab206963469b9199de462b8be15
imports_resolved_ast: 1bf9b30e052d9ecc042a0b20bbc195a98d463ab206963469b9199de462b8be15
canonicalized_ast: 1bf9b30e052d9ecc042a0b20bbc195a98d463ab206963469b9199de462b8be15
type_inferenced_ast: 6d2531af8ed5b04b23039d0b508cf388135a0fc6e1dc0de3befb4d49ce360fbc
imports_resolved_ast: 5deb917842e525eb21498976389bc21b716fc2c8d01ee15a868ec347da41eefc
canonicalized_ast: 5deb917842e525eb21498976389bc21b716fc2c8d01ee15a868ec347da41eefc
type_inferenced_ast: 1cce48ed4862ddb282cb08be969db4d9be64373e83a9458174f2fd63a5a2e878

6
tests/expectations/compiler/compiler/array/spread.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 140097342b7a16fae8542da5d13eb9c2cb4e1b743fa226e345d815f62d0781bb
imports_resolved_ast: 140097342b7a16fae8542da5d13eb9c2cb4e1b743fa226e345d815f62d0781bb
canonicalized_ast: 140097342b7a16fae8542da5d13eb9c2cb4e1b743fa226e345d815f62d0781bb
type_inferenced_ast: a2442e72c5010224894e46a1c6f245356c0d86428ce617eb31faaf57806ca2df
imports_resolved_ast: 691c76eae0533ac08a723ea21c999e9c8fafb71d81dd5a1ff5cf856d98b79cd9
canonicalized_ast: 691c76eae0533ac08a723ea21c999e9c8fafb71d81dd5a1ff5cf856d98b79cd9
type_inferenced_ast: 6bce331b2bcabd251d039695ea7821e39864bf37f9ba255ab743dddba26c6643

6
tests/expectations/compiler/compiler/array/ternary_in_array.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 002cb467a5c1357617b45f955944bb4a79ab465dc13f3eb5eb8db4c158b8c745
imports_resolved_ast: 002cb467a5c1357617b45f955944bb4a79ab465dc13f3eb5eb8db4c158b8c745
canonicalized_ast: 002cb467a5c1357617b45f955944bb4a79ab465dc13f3eb5eb8db4c158b8c745
type_inferenced_ast: 323fc99ac247b37bb395eb08691d451a3b6b563a15bb94b5af6a0193ccc0bd34
imports_resolved_ast: f6f225fdc57fa21359f0188361043bc7dc653cadec3936d4a94cf0c19058cb89
canonicalized_ast: f6f225fdc57fa21359f0188361043bc7dc653cadec3936d4a94cf0c19058cb89
type_inferenced_ast: 9203e04d2522f45db24dfd1582d6d5708256483a9eb52474b1ab006bfa1e8121

6
tests/expectations/compiler/compiler/array/tuple_3x2_value.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 97fd9b78f7912a7627e2b2f5615ae35e39304af6122fab85f9b49fcf6a85d8f2
imports_resolved_ast: 97fd9b78f7912a7627e2b2f5615ae35e39304af6122fab85f9b49fcf6a85d8f2
canonicalized_ast: cf8a8faae5f2847199324cbef87583e9af1249c03891ae31f3ce0093879326d5
type_inferenced_ast: 731117b4aa8260da475471088df325cb540d84c536ce60f3488e01a4428e84ae
imports_resolved_ast: 4132a31ee94a7c187c50f27d1992e25f346bd3c6efabf02106a62a814d9b336a
canonicalized_ast: b130bb4ab886d1d855d1f7afbd6af787f7681fbedbd05fcd1cd2561224695bac
type_inferenced_ast: a6a9b6069b3f805da8a6ea4fe2fb0530a24b19eb9687ef047f8f3b49d5497590

6
tests/expectations/compiler/compiler/array/type_input_3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 9f2080fab6a85294afa2423cd79482fb3d944c4afab7363e66a4086a120ad34d
imports_resolved_ast: 9f2080fab6a85294afa2423cd79482fb3d944c4afab7363e66a4086a120ad34d
canonicalized_ast: 9f2080fab6a85294afa2423cd79482fb3d944c4afab7363e66a4086a120ad34d
type_inferenced_ast: f8c6b9a9ac418220c87bbd1a99a5eb15817cfa289d822624f2d3cc41e10718b4
imports_resolved_ast: 266d7ddeb032f20a481e8477ee3ef1c15a33cb2e0fc6f1edd88505a92b6f98c5
canonicalized_ast: 266d7ddeb032f20a481e8477ee3ef1c15a33cb2e0fc6f1edd88505a92b6f98c5
type_inferenced_ast: 76a31fb9c0d35124f8af084baf96d54d1578a3234e3672c7003043412b915549

6
tests/expectations/compiler/compiler/array/type_input_4x3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: f61370b311806223d351c6dd611a178362cf8ad6de976d7b0ed709b51fadbecb
imports_resolved_ast: f61370b311806223d351c6dd611a178362cf8ad6de976d7b0ed709b51fadbecb
canonicalized_ast: f61370b311806223d351c6dd611a178362cf8ad6de976d7b0ed709b51fadbecb
type_inferenced_ast: 54531d6afced0deaa59c93b9270768a5e89ea8ea1df34365eb4e440bdf725904
imports_resolved_ast: 807d9de7b230026104c0b79e1211028db73f43914e40e5f0d11f86b0cf43b35e
canonicalized_ast: 807d9de7b230026104c0b79e1211028db73f43914e40e5f0d11f86b0cf43b35e
type_inferenced_ast: 4a8c4abf672625e2e998c83c7b7247b01d338dc496481b9847973946d45d8f18

6
tests/expectations/compiler/compiler/array/type_nested_value_nested_3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 6bacdd1d42bfa807910c0455c68213007d5ca8f15ee1f3c743d946bfbbff79b7
imports_resolved_ast: 6bacdd1d42bfa807910c0455c68213007d5ca8f15ee1f3c743d946bfbbff79b7
canonicalized_ast: 6bacdd1d42bfa807910c0455c68213007d5ca8f15ee1f3c743d946bfbbff79b7
type_inferenced_ast: 1b2a08879a8d42fafc9eecc12b89f0f36719e02205ee48bf6075475e71942132
imports_resolved_ast: 2abfe6c0c9d3d0d643ddb315c21c3a79ae7f4ffdb8fb3b2d662d9b2487951374
canonicalized_ast: 2abfe6c0c9d3d0d643ddb315c21c3a79ae7f4ffdb8fb3b2d662d9b2487951374
type_inferenced_ast: 18da5bbd315adf557e0041af34f6853acf311095e56a249fa1aa734de8d4ab60

6
tests/expectations/compiler/compiler/array/type_nested_value_nested_4x3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: c3c30cd2e66f21abef8c49e0ac3d49ed3b607097815c354b14ea9e44d41c0a69
imports_resolved_ast: c3c30cd2e66f21abef8c49e0ac3d49ed3b607097815c354b14ea9e44d41c0a69
canonicalized_ast: c3c30cd2e66f21abef8c49e0ac3d49ed3b607097815c354b14ea9e44d41c0a69
type_inferenced_ast: 557825e28344c8313d9961f9551eabe9c32ee85c524b9b9a6b0fc202c22fa9f3
imports_resolved_ast: 415d47125939d2d4466c2a940e34039bc6654036793e3828ce266f26e99b68e9
canonicalized_ast: 415d47125939d2d4466c2a940e34039bc6654036793e3828ce266f26e99b68e9
type_inferenced_ast: 2c78c46fc265667040e64ad396a702947197f4e1b2fc19af9cafddd8d233bdc9

6
tests/expectations/compiler/compiler/array/type_nested_value_tuple_3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 6c062f01a78d515f780a4c13de65d466edda274a2cb519af47a319ed165db0fa
imports_resolved_ast: 6c062f01a78d515f780a4c13de65d466edda274a2cb519af47a319ed165db0fa
canonicalized_ast: 382e9b8b4a635b0be6f62409a20bbdc10d37d08c17658414d1ddef8e6eb00749
type_inferenced_ast: 13d8af6038fbc63ae76be51f23e43152ab473b895d206160716008da87da3416
imports_resolved_ast: d89c5ba774b429aed589ec52560063cc1576ccdd92014108eb3996bdc8846748
canonicalized_ast: 724f20553f461602709c1cd1c0f9c86cd65b7f8281f47ebce221decdaf1d4403
type_inferenced_ast: bbda06e9afda5ad60c8e4fe0e8e7c7d513c16027bcd5b6efbc2ce981706aa853

6
tests/expectations/compiler/compiler/array/type_nested_value_tuple_4x3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 228ba794b578de8828d761676c15059c51455aff96b02ef3cfafbef53c35454b
imports_resolved_ast: 228ba794b578de8828d761676c15059c51455aff96b02ef3cfafbef53c35454b
canonicalized_ast: 7869bd9531ba014bc2515e13bcafdfed2f9566e7008c1e015d43bb749d8d1d4a
type_inferenced_ast: 84b8976993f08b1b46fef6012018ad050eed6df1e34ae83fc0b57799a1acb395
imports_resolved_ast: 7ab2c61eaf51aac67c90f364162e209adc4fc89da67e3be674941456289cadfe
canonicalized_ast: d58af0791643776db1c266ea3f78582922d47a5e31cd39b73910139bff6c4aaa
type_inferenced_ast: 38ea7a4cbb6fc2ae4c9671acb4747e5ee3c8b61d17328b18c23b9f4c5dde6466

6
tests/expectations/compiler/compiler/array/type_tuple_value_nested_3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 0ea5856bbe7ad96107544e2b12c7ca54c279c4cd1c8b9610083430600ffa86f9
imports_resolved_ast: 0ea5856bbe7ad96107544e2b12c7ca54c279c4cd1c8b9610083430600ffa86f9
canonicalized_ast: 0083c78a81a6ec44627ca89fe949a5301ccaa54ead7104b9a2a3fbd979cf9a2c
type_inferenced_ast: a8b44ce543535e16db5d93df805dc5693d3a1140798cb336d573986de8dfdbca
imports_resolved_ast: c409a94fbb07fd687e830270c28acbbab31d39c646f551834968ff34c974236f
canonicalized_ast: 55407a1c8968dfc96aa4f5f1b3183b6361a6a95b829855cc955d09ac5f428733
type_inferenced_ast: 83f98c57d8cb35f70a4eed0814e72ee490999e858c3b798c86cd9668894b46d9

6
tests/expectations/compiler/compiler/array/type_tuple_value_nested_4x3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: db7e9050580f794aa657700225126e8033c0241240874f6e35df0507469be247
imports_resolved_ast: db7e9050580f794aa657700225126e8033c0241240874f6e35df0507469be247
canonicalized_ast: 55304d82a024ad2418e156ad661224040904775f070995bf1b828d1264c3487f
type_inferenced_ast: db99dd94ad4ef9de46304df000494eeda3e8b51835c46e6a3988ee87f91457fa
imports_resolved_ast: 5df26baf4758af1c8c4556520ad08f2940269996b74142d1d1d3d35dd8747e40
canonicalized_ast: 3767f6efa3939259c0736d50e9924901dafdd2625254c38ad4d300c0a300c886
type_inferenced_ast: 93ac6b8b3d53c3c0ea5469c3a13ffe5a72fefe403dee16728453c4f182e04a2d

6
tests/expectations/compiler/compiler/array/type_tuple_value_tuple_3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 2730f954bc76f81d29b02a15f8025d75ca963234716112745b806789bb8eb297
imports_resolved_ast: 2730f954bc76f81d29b02a15f8025d75ca963234716112745b806789bb8eb297
canonicalized_ast: 4e07d5e399fa0f60ab84796ecc6195b2a8da0b3a9e725152465512e98f0ca753
type_inferenced_ast: ea0f726ce456c52c62b73aae38afb74b160ae527480d05f3254c0fdaefdad58e
imports_resolved_ast: b516a9bd2db8c0d95549a81b4437eccb8f911585c380eaf3e1f4778ffc7d6136
canonicalized_ast: 7d507bbe756202e754f5775dbacbc5ea17403ea6b320b341e0d3670edd980c55
type_inferenced_ast: 219ac85c47e69d451307b5dbd9735df3880ca3610b656f1ce56b96f77a769292

6
tests/expectations/compiler/compiler/array/type_tuple_value_tuple_4x3x2.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 445b35e7d287dc14a77b2c1c4c77d9b7b4fbd6e7c31f6f35c91a446eeca29775
imports_resolved_ast: 445b35e7d287dc14a77b2c1c4c77d9b7b4fbd6e7c31f6f35c91a446eeca29775
canonicalized_ast: 48590d7afce08e9e0cd4a45048faa360c18109098b5a9074dfc21b252a47d3e8
type_inferenced_ast: 0cc5d17973908631180a791f151bdc42aa3e8394b3fbc7607f717bc61baaf904
imports_resolved_ast: 594999cfccea90f0116cf0e231a7019bfd25ea7ff667d2f79ad1c1b510c823e0
canonicalized_ast: 76a85bbddcb8c9b32fedbfdd1fe4d69721f4e627fb119aa358c3f18137921f51
type_inferenced_ast: 3f188b49692f395400046c319dc1c73a235891a8e8a4bcb93b827a433b7de71c

6
tests/expectations/compiler/compiler/array_without_size/definition.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: edf8a3b7372af353b99830752d41d8c04d1863a4d03c754f41aac3545649c644
imports_resolved_ast: edf8a3b7372af353b99830752d41d8c04d1863a4d03c754f41aac3545649c644
canonicalized_ast: edf8a3b7372af353b99830752d41d8c04d1863a4d03c754f41aac3545649c644
type_inferenced_ast: 5479f110a1cbd68040560f64a09663207e756630aa2621a4bb424c48a3cab64d
imports_resolved_ast: f0dbd5c30713c383c8e0a0cc1661540dcc7d2c8ac6411a6a93bed59b6d6ce546
canonicalized_ast: f0dbd5c30713c383c8e0a0cc1661540dcc7d2c8ac6411a6a93bed59b6d6ce546
type_inferenced_ast: dd228d9d9fa611408636d6a307fd69cd18e7293a08a611ac2f88883d1b978032

6
tests/expectations/compiler/compiler/array_without_size/function_input.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 5ae730ffb3671acde08944aaa8450a54bb9ce436c92d5c21e7a2a7b9c8d404a7
imports_resolved_ast: 5ae730ffb3671acde08944aaa8450a54bb9ce436c92d5c21e7a2a7b9c8d404a7
canonicalized_ast: 5ae730ffb3671acde08944aaa8450a54bb9ce436c92d5c21e7a2a7b9c8d404a7
type_inferenced_ast: c2b15c1e0644a4af597019f7a56d1c8485723e43089ff0aa8951e3ec31729f1f
imports_resolved_ast: b0a3019e9e93ae0990bce7ffe2b1e075c0ba4f517aacc42c2bd56ebcb15ee1e3
canonicalized_ast: b0a3019e9e93ae0990bce7ffe2b1e075c0ba4f517aacc42c2bd56ebcb15ee1e3
type_inferenced_ast: 945eef156080f8d2c99f4f34464861a2376ff7261fb6b393ea7dc2b84f30f328

6
tests/expectations/compiler/compiler/array_without_size/type_alias.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 0e8ea2eb2de2ad93883ced129ab7c42674fd476d94ede483f5ea042f8386b730
imports_resolved_ast: 0e8ea2eb2de2ad93883ced129ab7c42674fd476d94ede483f5ea042f8386b730
canonicalized_ast: 529ba1d5564ef0c1752343e3e6e8b181f13bec0620c4ecbe23080ef4a080cb2b
type_inferenced_ast: b4d3305f7179dfc2a7a330e538a41e3cdf51f12e4a6545cd57ff9a2e5a9d1db0
imports_resolved_ast: a86e55392b72b3b309d6223d7304035611b1e397580c16839545579d9a95c9ea
canonicalized_ast: f202f6e13729555eed8c48727e7df16f72ba3addd62dff7269814acf297f98a1
type_inferenced_ast: bd9592a3af130293e2a71a7dbad84805958d857d41be1b39326b5e12c1f7af81

6
tests/expectations/compiler/compiler/boolean/and.leo.out
View File

@ -35,6 +35,6 @@ outputs:
type: bool
value: "true"
initial_ast: 2f7c3b9c806a873b6445200eb78a8e0e546ffe64c90fe2133355dd37a342b11b
imports_resolved_ast: 2f7c3b9c806a873b6445200eb78a8e0e546ffe64c90fe2133355dd37a342b11b
canonicalized_ast: 2f7c3b9c806a873b6445200eb78a8e0e546ffe64c90fe2133355dd37a342b11b
type_inferenced_ast: 87b86a66fc6e60502be0b0fb7cf677d5128390aec53f6893827a1bf02fca8370
imports_resolved_ast: 8c8039a942ada73357ce62cbf478d1252b4c1b022bdf156a8beb8b1f41898efb
canonicalized_ast: 8c8039a942ada73357ce62cbf478d1252b4c1b022bdf156a8beb8b1f41898efb
type_inferenced_ast: 460e99eaaaf5de2d28b19a692c455bb12d3540503624aeffe281057fbeddb352

6
tests/expectations/compiler/compiler/boolean/conditional.leo.out
View File

@ -35,6 +35,6 @@ outputs:
type: bool
value: "true"
initial_ast: 5316ba00882aa3f9b538d349ed7141c4ee7c77ec01f6af9911b2652b6cd3e659
imports_resolved_ast: 5316ba00882aa3f9b538d349ed7141c4ee7c77ec01f6af9911b2652b6cd3e659
canonicalized_ast: 5316ba00882aa3f9b538d349ed7141c4ee7c77ec01f6af9911b2652b6cd3e659
type_inferenced_ast: 7933d0a8f47892e42c3c670bc6433e8d820042a7396e10b6a63d22bd5b740f96
imports_resolved_ast: 96c21aa198ea648d52822abba76f43248dc5701232c0331bdc88b4e7596f894e
canonicalized_ast: 96c21aa198ea648d52822abba76f43248dc5701232c0331bdc88b4e7596f894e
type_inferenced_ast: 9869ac26b6eaa9d2f97d910b061dce142d7ca6a51f3defd813987f0138fb5fc1

6
tests/expectations/compiler/compiler/boolean/equal.leo.out
View File

@ -35,6 +35,6 @@ outputs:
type: bool
value: "true"
initial_ast: 08f026e24cab51634a7a2a6f1f3b082eace1d4be649cd9ff7c244194891d7d78
imports_resolved_ast: 08f026e24cab51634a7a2a6f1f3b082eace1d4be649cd9ff7c244194891d7d78
canonicalized_ast: 08f026e24cab51634a7a2a6f1f3b082eace1d4be649cd9ff7c244194891d7d78
type_inferenced_ast: 2112e9f631a77bb16ba1561bbe1028a415413f23fd32d21bfe086e071938c845
imports_resolved_ast: dac2c874c2a6780c36245c75dc2be130aed8bb563911aaa7d1e30a3a4abd5e01
canonicalized_ast: dac2c874c2a6780c36245c75dc2be130aed8bb563911aaa7d1e30a3a4abd5e01
type_inferenced_ast: 647de266dbd67a1f2cbf40904422e699066aa033470501c7b0dac0010e943ce5

6
tests/expectations/compiler/compiler/boolean/not_equal.leo.out
View File

@ -35,6 +35,6 @@ outputs:
type: bool
value: "false"
initial_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95
imports_resolved_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95
canonicalized_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95
type_inferenced_ast: ab25cb7bf7d8fe3ec64be183550ba8d6acfaf17464cf70ec45c6497fc065ac29
imports_resolved_ast: 1d9d8399fe44bade2bd762e88a1db5805b26cb47710aea505ca5d33a60daa574
canonicalized_ast: 1d9d8399fe44bade2bd762e88a1db5805b26cb47710aea505ca5d33a60daa574
type_inferenced_ast: 8438f2a6c2db2f16ec11a4f12d0085039e6cd22e9106d14c25d1bbfe55c1df9e

6
tests/expectations/compiler/compiler/boolean/or.leo.out
View File

@ -35,6 +35,6 @@ outputs:
type: bool
value: "true"
initial_ast: e2facdce5f7cdbed4a3215cc258e54418aac4f4b846349b35e1da67b577b76c9
imports_resolved_ast: e2facdce5f7cdbed4a3215cc258e54418aac4f4b846349b35e1da67b577b76c9
canonicalized_ast: e2facdce5f7cdbed4a3215cc258e54418aac4f4b846349b35e1da67b577b76c9
type_inferenced_ast: fb43dcb50c9822e2d4e4f35e9cc73f0893e508161296be5666cd90c4f7a971bc
imports_resolved_ast: c82afe6fc023e46a02cfe669c6d90c6da47e71673b3e60dd40e5e976799865db
canonicalized_ast: c82afe6fc023e46a02cfe669c6d90c6da47e71673b3e60dd40e5e976799865db
type_inferenced_ast: 1af91788f2e6709d95c35e6719238710b4ae2ed6794f59d565c4bfda31aa23d9

6
tests/expectations/compiler/compiler/char/circuit.leo.out
View File

@ -101,6 +101,6 @@ outputs:
type: char
value: "'\\u{1f62d}'"
initial_ast: 0c2aeb5b47fc21f5aded4e3aebcdf55eb98c10c6b51a2a6dcb98490a96da0c97
imports_resolved_ast: 0c2aeb5b47fc21f5aded4e3aebcdf55eb98c10c6b51a2a6dcb98490a96da0c97
canonicalized_ast: 0c2aeb5b47fc21f5aded4e3aebcdf55eb98c10c6b51a2a6dcb98490a96da0c97
type_inferenced_ast: e9c5fc64aad2390305671ffbe316eee04d5fca7a6f09dcc8c8a69c38db8b3a62
imports_resolved_ast: dc29924de4b1752b8e29691b4e6938d20048c684a8e01e77b760f75b76507747
canonicalized_ast: dc29924de4b1752b8e29691b4e6938d20048c684a8e01e77b760f75b76507747
type_inferenced_ast: 0db49560694863b30bba8e3243ae034956c397249031215042b1615d99d397b7

6
tests/expectations/compiler/compiler/char/neq.leo.out
View File

@ -101,6 +101,6 @@ outputs:
type: char
value: "'a'"
initial_ast: ac56e34b2a2cb282d36133df39d80947dfdfc56b5655b3ba9f408ba529c8f505
imports_resolved_ast: ac56e34b2a2cb282d36133df39d80947dfdfc56b5655b3ba9f408ba529c8f505
canonicalized_ast: ac56e34b2a2cb282d36133df39d80947dfdfc56b5655b3ba9f408ba529c8f505
type_inferenced_ast: 2eecf906226893c46f526a72f272a3f11eb34ada7cc4cd573439ebfed44ba170
imports_resolved_ast: 11a4df3cb6ce54c7ee28b94b4e0a728b7a4895c8907b1a168e4ec726b316f093
canonicalized_ast: 11a4df3cb6ce54c7ee28b94b4e0a728b7a4895c8907b1a168e4ec726b316f093
type_inferenced_ast: 5b4c5ecb456864365fb66a730386b7dd6fc25427a1aaea5fb8c7017ede56bc32

6
tests/expectations/compiler/compiler/char/nonprinting.leo.out
View File

@ -20,6 +20,6 @@ outputs:
type: bool
value: "true"
initial_ast: da8550065db88bba8f0a982612194f6122ec97025c4af5d3007d3a4d42519cb9
imports_resolved_ast: da8550065db88bba8f0a982612194f6122ec97025c4af5d3007d3a4d42519cb9
canonicalized_ast: da8550065db88bba8f0a982612194f6122ec97025c4af5d3007d3a4d42519cb9
type_inferenced_ast: b3ea99e7660209825c5bb1abcba8c1835cf96b79c8707e616513122ab10ac0d5
imports_resolved_ast: fde01d86d58dfcbddd1ab58393dfd3ce4af3df4160b7d2971e983141dee607c5
canonicalized_ast: fde01d86d58dfcbddd1ab58393dfd3ce4af3df4160b7d2971e983141dee607c5
type_inferenced_ast: f63a99ba7e7a5d37f93aeadfd01d62be4f4eaffad986054093922499b0c9f062

6
tests/expectations/compiler/compiler/char/out.leo.out
View File

@ -101,6 +101,6 @@ outputs:
type: char
value: "'\\u{1f62d}'"
initial_ast: 6e1cf86d47e056682c6e51dcf0390eb34505b60d50de60970a688f237525bedf
imports_resolved_ast: 6e1cf86d47e056682c6e51dcf0390eb34505b60d50de60970a688f237525bedf
canonicalized_ast: 6e1cf86d47e056682c6e51dcf0390eb34505b60d50de60970a688f237525bedf
type_inferenced_ast: feb16e72f13a884e3303b336f7f20ff8ff4066a8f9861860e28b9c6901215b76
imports_resolved_ast: e9012d76c33c37f3940fbc8f9d8fe83cb13d8b7bdaa5b8476180128f91132c71
canonicalized_ast: e9012d76c33c37f3940fbc8f9d8fe83cb13d8b7bdaa5b8476180128f91132c71
type_inferenced_ast: b19acb9ba2e6e5949839b5fe3d15f52f7187cadbb0602e44b03215f4181a6997

6
tests/expectations/compiler/compiler/circuits/big_self_in_circuit_replacement.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: ec52d3b3e69bef6d104f2dcfa9e713a728d7b0e15439c9da3b521b6cbfe719d4
imports_resolved_ast: ec52d3b3e69bef6d104f2dcfa9e713a728d7b0e15439c9da3b521b6cbfe719d4
canonicalized_ast: c85604dd75a964f7a6cfc0dddbeeeccf28a7c43915b944740528a0ff6230db78
type_inferenced_ast: 258670051ac595a600362cb5a6793fb5ba9361cd914f7483057ad66204fc1b36
imports_resolved_ast: add95914a89cb2686db8c906b94acca8e7dfcad9db26ad83a75c327e0eb19ca0
canonicalized_ast: 21d2efd19f936682f161dcdf804c30d745f47201a5702de7ceecf81544291561
type_inferenced_ast: 0814bcdc1e7422f32192c44a7b4a12b0d4b9f2e5ef612521c73800fc3e27dfcb

6
tests/expectations/compiler/compiler/circuits/const_self_variable.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 50c0f7261d879373f4e01ec3d140a2067ca4e78622c8340e8312d717f6effb05
imports_resolved_ast: 50c0f7261d879373f4e01ec3d140a2067ca4e78622c8340e8312d717f6effb05
canonicalized_ast: 50c0f7261d879373f4e01ec3d140a2067ca4e78622c8340e8312d717f6effb05
type_inferenced_ast: 68174a753a3191ea961db29f62b6557f410ee33c2cad28c43a5098bb6cb230f2
imports_resolved_ast: d2bdb4665f5a49124335ba3f3fb39d8dc5a6f4d08d53e84fec635cd27d5eb582
canonicalized_ast: d2bdb4665f5a49124335ba3f3fb39d8dc5a6f4d08d53e84fec635cd27d5eb582
type_inferenced_ast: edbc4ba37f4a02c487f70b4a0d245154848e54336213420d5ddd2c1f8b966029

6
tests/expectations/compiler/compiler/circuits/define_circuit_inside_circuit_function.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: bfd7751e8ea64c6d41af36d968f194a18a5411ac71932a67766f40448ce755f5
imports_resolved_ast: bfd7751e8ea64c6d41af36d968f194a18a5411ac71932a67766f40448ce755f5
canonicalized_ast: bfd7751e8ea64c6d41af36d968f194a18a5411ac71932a67766f40448ce755f5
type_inferenced_ast: c6ca022e97bef335bf6df235875d507240eb48ea28f6504cc17c3d09820430f9
imports_resolved_ast: 58a6b067cffc10de35b10a84f7e200fe836890c758174c8126cc4a20417a4c24
canonicalized_ast: 58a6b067cffc10de35b10a84f7e200fe836890c758174c8126cc4a20417a4c24
type_inferenced_ast: 7b55011299b213dd63dae23315ad0029c6057c46a2ad53f30b28fbdfb5b72934

6
tests/expectations/compiler/compiler/circuits/duplicate_name_context.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: d8a66347f480161a2215c92d2cf6ded2d0b49fd76b7eb0036d4fa33de371925a
imports_resolved_ast: d8a66347f480161a2215c92d2cf6ded2d0b49fd76b7eb0036d4fa33de371925a
canonicalized_ast: d8a66347f480161a2215c92d2cf6ded2d0b49fd76b7eb0036d4fa33de371925a
type_inferenced_ast: cb82c955829007961356ca2760b6ca84e2ea321cd640e87d4a51fd3ba65eb7a7
imports_resolved_ast: 23ab7ce1f8ade033ad2c0e0a488e3da059795059ffd85bff240436502baff064
canonicalized_ast: 23ab7ce1f8ade033ad2c0e0a488e3da059795059ffd85bff240436502baff064
type_inferenced_ast: f33e938ad318bd26d2249c7aff5880fd78bb95b3cb8b335a8483830a1be47d4e

6
tests/expectations/compiler/compiler/circuits/inline.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: u32
value: "100"
initial_ast: c40a1d60f872fdb03ab7379a3abf43439a100b8f1546b76ffeac60c8739e0d68
imports_resolved_ast: c40a1d60f872fdb03ab7379a3abf43439a100b8f1546b76ffeac60c8739e0d68
canonicalized_ast: c40a1d60f872fdb03ab7379a3abf43439a100b8f1546b76ffeac60c8739e0d68
type_inferenced_ast: 2221472ded58b4a6c77545040ca32138d68eb6f2c3e47b830317872f045f91f8
imports_resolved_ast: f8c489b07e7dc45c8d42f959cdae47a61101e5fc6110f378af0a34fe41b1777e
canonicalized_ast: f8c489b07e7dc45c8d42f959cdae47a61101e5fc6110f378af0a34fe41b1777e
type_inferenced_ast: 87619e2e5d2e6a22ed58c5d7938062a074faef5e6bc1ee60036a8050e3271c2f

6
tests/expectations/compiler/compiler/circuits/inline_member_pass.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: cf642f2f983cd8bcd6cbca2d2920f5234d79375601c1da3c06f97b6185a5629d
imports_resolved_ast: cf642f2f983cd8bcd6cbca2d2920f5234d79375601c1da3c06f97b6185a5629d
canonicalized_ast: de45d7a621a1309ca9ae0dd11f4a99e8ff1e0b92c9f990d2f72a6c43067a7611
type_inferenced_ast: 690a93dcec9c31c26b52ca234ce8e07067649c038e47fd8b7eeef9e36dddf05b
imports_resolved_ast: ec5c0b1e01e74181406efc8a2b698933726e13e92c87e0fac7dcb28901ed9565
canonicalized_ast: b9cf563cea162726122f7d2f7f264dace0c2d6a75e58c13e745fd849404da067
type_inferenced_ast: 2e83ce8e0fc851ff003c9e2756c0e0d83364b506e87e2189df473c306814eea8

6
tests/expectations/compiler/compiler/circuits/member_function.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 5273a592b167cfe040b2bca7337521084d7a6640651bca584545e9eeb2e4fa88
imports_resolved_ast: 5273a592b167cfe040b2bca7337521084d7a6640651bca584545e9eeb2e4fa88
canonicalized_ast: 5273a592b167cfe040b2bca7337521084d7a6640651bca584545e9eeb2e4fa88
type_inferenced_ast: ee2152aedd637adcfdd84540bfd8814c65cc8552c0bae80a0176b91d70b1266e
imports_resolved_ast: 2b5126eef050bdfdb68da8587756219441517fcd1c704c8f9d1ea102392b1580
canonicalized_ast: 2b5126eef050bdfdb68da8587756219441517fcd1c704c8f9d1ea102392b1580
type_inferenced_ast: 4a42f661d6de987682e28824a97d3989ddd5444d51620d77bc6637abd876c425

6
tests/expectations/compiler/compiler/circuits/member_function_nested.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 241f1a42877b012b2e2062cefbd83523a5c719557cb422cf1fbd7efb0f7b1796
imports_resolved_ast: 241f1a42877b012b2e2062cefbd83523a5c719557cb422cf1fbd7efb0f7b1796
canonicalized_ast: 241f1a42877b012b2e2062cefbd83523a5c719557cb422cf1fbd7efb0f7b1796
type_inferenced_ast: e063513fb0d009c0cadd36cab9feb4327528bbba45087d7a65e0e97fcd54bb7a
imports_resolved_ast: 43cca11f696228d0707095273602f51aab997eb3f85309f731d0af3a69bdeb47
canonicalized_ast: 43cca11f696228d0707095273602f51aab997eb3f85309f731d0af3a69bdeb47
type_inferenced_ast: a81ca1868d802d53a7a541bca7a021ad233d58a2d2ec9ad197ff2f2bcdde8495

6
tests/expectations/compiler/compiler/circuits/member_static_function.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 11dfbfa2561534a1c965d8f8862b23ed56be50986903c139b763f88a1ba3ad8d
imports_resolved_ast: 11dfbfa2561534a1c965d8f8862b23ed56be50986903c139b763f88a1ba3ad8d
canonicalized_ast: 11dfbfa2561534a1c965d8f8862b23ed56be50986903c139b763f88a1ba3ad8d
type_inferenced_ast: 6aab6f0cf6a9237ec02b5ce3f4ad8f24c8faa8ec5ccbc7f3af1023d0269dceea
imports_resolved_ast: e0a8c32b321be274b67e4ec4897857d614924a6cc4a52c30b7d8d7ff848871d3
canonicalized_ast: e0a8c32b321be274b67e4ec4897857d614924a6cc4a52c30b7d8d7ff848871d3
type_inferenced_ast: 72b7a987240d2efac67d0d0972f685ddfda6d123035455873cc5d9f1818557b6

6
tests/expectations/compiler/compiler/circuits/member_static_function_nested.leo.out
View File

@ -17,6 +17,6 @@ outputs:
type: bool
value: "true"
initial_ast: 42f603efbf7ee8ca53394266f33fbf09110420c822385179d656861e8ceb4a32
imports_resolved_ast: 42f603efbf7ee8ca53394266f33fbf09110420c822385179d656861e8ceb4a32
canonicalized_ast: 92d91209d7675fc14ae1fd44c28d1384f1c56c5852654b4dac46dd123340d9c0
type_inferenced_ast: 0527005fb0925ac29af65bb0c12c39991d466c20def41ce7e4a2ded51ae233fc
imports_resolved_ast: 5d6286f1296a269e2b39ec7e6a73257317eb6ce37bb11bce26f34b7f7fba3501
canonicalized_ast: ddea7b51d7e218ff02e44be3737128309dabc76d54838db4967a89e901241899
type_inferenced_ast: 5c828c5b2324057bd9543a6fafa47f8752cbd33bebf6b5fc186ed121580d791b

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