diff --git a/Cargo.lock b/Cargo.lock index 4d1b6d83a2..6723bf257e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1587,21 +1587,6 @@ dependencies = [ "tempfile", ] -[[package]] -name = "leo-cst" -version = "2.1.0" -dependencies = [ - "criterion", - "indexmap 1.9.3", - "itertools 0.13.0", - "leo-errors", - "leo-span", - "serde", - "serde_json", - "smallvec", - "snarkvm", -] - [[package]] name = "leo-disassembler" version = "2.1.0" diff --git a/Cargo.toml b/Cargo.toml index 1169070bb2..d1d224a3c1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -32,7 +32,6 @@ edition = "2021" members = [ "compiler/ast", "compiler/compiler", - "compiler/cst", "compiler/parser", "compiler/passes", "compiler/span", diff --git a/compiler/cst/src/statement/definition/declaration_type.rs b/compiler/ast/src/common/comment.rs similarity index 68% rename from compiler/cst/src/statement/definition/declaration_type.rs rename to compiler/ast/src/common/comment.rs index d737b5355d..e953aa238c 100644 --- a/compiler/cst/src/statement/definition/declaration_type.rs +++ b/compiler/ast/src/common/comment.rs @@ -17,20 +17,17 @@ use serde::{Deserialize, Serialize}; use std::fmt; -/// The sort of bindings to introduce, either `let` or `const`. -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub enum DeclarationType { - /// This is a `const` binding. - Const, - /// This is a `let` binding. - Let, +#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq, )] +pub enum Comment { + CommentLine(String), + CommentBlock(String) } -impl fmt::Display for DeclarationType { +impl fmt::Display for Comment { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { - DeclarationType::Const => write!(f, "const"), - DeclarationType::Let => write!(f, "let"), + Comment::CommentLine(content) => write!(f, "{}", content), + Comment::CommentBlock(content) => writeln!(f, "{}", content), } } -} +} \ No newline at end of file diff --git a/compiler/ast/src/common/mod.rs b/compiler/ast/src/common/mod.rs index a574e9b628..0d8749df54 100644 --- a/compiler/ast/src/common/mod.rs +++ b/compiler/ast/src/common/mod.rs @@ -33,3 +33,6 @@ pub use node_builder::*; pub mod static_string; pub use static_string::*; + +pub mod comment; +pub use comment::*; \ No newline at end of file diff --git a/compiler/ast/src/lib.rs b/compiler/ast/src/lib.rs index 19ef53784a..0e21d48213 100644 --- a/compiler/ast/src/lib.rs +++ b/compiler/ast/src/lib.rs @@ -60,6 +60,9 @@ pub mod value; pub mod stub; pub use self::stub::*; +pub mod program_cst; +pub use self::program_cst::*; + pub use self::value::*; pub use common::node::*; @@ -74,6 +77,9 @@ use leo_errors::{AstError, Result}; pub struct Ast { pub ast: Program, } +pub struct Cst { + pub cst: CSTProgram +} impl Ast { /// Creates a new AST from a given program tree. @@ -152,6 +158,83 @@ impl AsRef for Ast { } } +impl Cst { + /// Creates a new AST from a given program tree. + pub fn new(program: CSTProgram) -> Self { + Self { cst: program } + } + + /// Returns a reference to the inner program AST representation. + pub fn as_repr(&self) -> &CSTProgram { + &self.cst + } + + pub fn into_repr(self) -> CSTProgram { + self.cst + } + + /// Serializes the ast into a JSON string. + pub fn to_json_string(&self) -> Result { + Ok(serde_json::to_string_pretty(&self.cst).map_err(|e| AstError::failed_to_convert_ast_to_json_string(&e))?) + } + + // Converts the ast into a JSON value. + // Note that there is no corresponding `from_json_value` function + // since we modify JSON values leaving them unable to be converted + // back into Programs. + pub fn to_json_value(&self) -> Result { + Ok(serde_json::to_value(&self.cst).map_err(|e| AstError::failed_to_convert_ast_to_json_value(&e))?) + } + + /// Serializes the ast into a JSON file. + pub fn to_json_file(&self, mut path: std::path::PathBuf, file_name: &str) -> Result<()> { + path.push(file_name); + let file = std::fs::File::create(&path).map_err(|e| AstError::failed_to_create_ast_json_file(&path, &e))?; + let writer = std::io::BufWriter::new(file); + Ok(serde_json::to_writer_pretty(writer, &self.cst) + .map_err(|e| AstError::failed_to_write_ast_to_json_file(&path, &e))?) + } + + /// Serializes the ast into a JSON value and removes keys from object mappings before writing to a file. + pub fn to_json_file_without_keys( + &self, + mut path: std::path::PathBuf, + file_name: &str, + excluded_keys: &[&str], + ) -> Result<()> { + path.push(file_name); + let file = std::fs::File::create(&path).map_err(|e| AstError::failed_to_create_ast_json_file(&path, &e))?; + let writer = std::io::BufWriter::new(file); + + let mut value = self.to_json_value().unwrap(); + for key in excluded_keys { + value = remove_key_from_json(value, key); + } + value = normalize_json_value(value); + + Ok(serde_json::to_writer_pretty(writer, &value) + .map_err(|e| AstError::failed_to_write_ast_to_json_file(&path, &e))?) + } + + /// Deserializes the JSON string into a ast. + pub fn from_json_string(json: &str) -> Result { + let cst: CSTProgram = serde_json::from_str(json).map_err(|e| AstError::failed_to_read_json_string_to_ast(&e))?; + Ok(Self { cst }) + } + + /// Deserializes the JSON string into a ast from a file. + pub fn from_json_file(path: std::path::PathBuf) -> Result { + let data = std::fs::read_to_string(&path).map_err(|e| AstError::failed_to_read_json_file(&path, &e))?; + Self::from_json_string(&data) + } +} + +impl AsRef for Cst { + fn as_ref(&self) -> &CSTProgram { + &self.cst + } +} + /// Helper function to recursively filter keys from AST JSON pub fn remove_key_from_json(value: serde_json::Value, key: &str) -> serde_json::Value { match value { diff --git a/compiler/ast/src/program_cst/mod.rs b/compiler/ast/src/program_cst/mod.rs new file mode 100644 index 0000000000..78d26a7034 --- /dev/null +++ b/compiler/ast/src/program_cst/mod.rs @@ -0,0 +1,81 @@ +// Copyright (C) 2019-2023 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 . + +//! A Leo program consists of import statements and program scopes. + +use super::*; + +use leo_span::{span::Pos, Span, Symbol}; + +use crate::{ Comment, Stub }; +use indexmap::IndexMap; +use serde::{Deserialize, Serialize}; +use std::fmt; + +/// Stores the Leo program abstract syntax tree. +#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] +pub struct CSTProgram { + /// A map from import names to import definitions. + pub imports: IndexMap, + /// A map from program stub names to program stub scopes. + pub stubs: IndexMap, + /// A map from program names to program scopes. + pub program_scopes: IndexMap, + /// A map from prefix names to comment. + pub comments: Vec<(Comment, usize)> +} +impl fmt::Display for CSTProgram { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let len = self.imports.len() + self.program_scopes.len() + self.comments.len() + self.stubs.len(); + for index in 0..len { + for (id, import) in self.imports.iter() { + if index == import.2 { + writeln!(f, "import {id}.leo;")?; + } + } + for (_, stub) in self.stubs.iter() { + if index == stub.1 { + stub.0.fmt(f)?; + writeln!(f,)?; + } + } + for (_, program_scope) in self.program_scopes.iter() { + if index == program_scope.1 { + program_scope.0.fmt(f)?; + } + } + for comment in &self.comments { + if index == comment.1 { + comment.0.fmt(f)?; + } + } + } + + Ok(()) + } +} + +impl Default for CSTProgram { + /// Constructs an empty program node. + fn default() -> Self { + Self { + imports: IndexMap::new(), + stubs: IndexMap::new(), + program_scopes: IndexMap::new(), + comments: vec![] + } + } +} diff --git a/compiler/cst/Cargo.toml b/compiler/cst/Cargo.toml deleted file mode 100644 index 4e1746b5ba..0000000000 --- a/compiler/cst/Cargo.toml +++ /dev/null @@ -1,56 +0,0 @@ -[package] -name = "leo-cst" -version = "2.1.0" -authors = [ "The Aleo Team " ] -description = "Concrete syntax tree (CST) for the Leo programming language" -homepage = "https://aleo.org" -repository = "https://github.com/AleoHQ/leo" -keywords = [ - "aleo", - "cryptography", - "leo", - "programming-language", - "zero-knowledge" -] -categories = [ "compilers", "cryptography", "web-programming" ] -include = [ "Cargo.toml", "src", "README.md", "LICENSE.md" ] -license = "GPL-3.0" -edition = "2021" -rust-version = "1.69" - -[dependencies.snarkvm] -workspace = true - -[dependencies.leo-errors] -path = "../../errors" -version = "2.1.0" - -[dependencies.leo-span] -path = "../span" -version = "2.1.0" - -[dependencies.indexmap] -version = "1.9" -features = [ "serde-1" ] - -[dependencies.itertools] -version = "0.13.0" - -[dependencies.serde] -version = "1.0" -features = [ "derive", "rc" ] - -[dependencies.serde_json] -version = "1.0" -features = [ "preserve_order" ] - -[dependencies.smallvec] -version = "1.13.1" -features = [ "serde" ] - -[dev-dependencies.criterion] -version = "0.5" - -[features] -default = [ ] -ci_skip = [ ] diff --git a/compiler/cst/LICENSE.md b/compiler/cst/LICENSE.md deleted file mode 100644 index b95c626e2a..0000000000 --- a/compiler/cst/LICENSE.md +++ /dev/null @@ -1,596 +0,0 @@ -GNU General Public License -========================== - -Version 3, 29 June 2007 - -Copyright © 2007 Free Software Foundation, Inc. <> - -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. - - - Copyright (C) - - 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 . - -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: - - Copyright (C) - 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 -<>. - -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 -<>. diff --git a/compiler/cst/README.md b/compiler/cst/README.md deleted file mode 100644 index 7455debf6c..0000000000 --- a/compiler/cst/README.md +++ /dev/null @@ -1,6 +0,0 @@ -# leo-cst - -[![Crates.io](https://img.shields.io/crates/v/leo-cst.svg?color=neon)](https://crates.io/crates/leo-cst) -[![Authors](https://img.shields.io/badge/authors-Aleo-orange.svg)](../AUTHORS) -[![License](https://img.shields.io/badge/License-GPLv3-blue.svg)](./LICENSE.md) - diff --git a/compiler/cst/src/access/array_access.rs b/compiler/cst/src/access/array_access.rs deleted file mode 100644 index 0e4672f97f..0000000000 --- a/compiler/cst/src/access/array_access.rs +++ /dev/null @@ -1,22 +0,0 @@ - - -use crate::{Expression, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// An array access expression, e.g., `foo[index]`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct ArrayAccess { - /// An expression evaluating to some array type, e.g., `[false, true]`. - pub array: Box, - /// The index to access in the array expression. E.g., `0` for `[false, true]` would yield `false`. - pub index: Box, - /// The span for the entire expression `foo[index]`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - - -crate::simple_node_impl!(ArrayAccess); diff --git a/compiler/cst/src/access/associated_constant_access.rs b/compiler/cst/src/access/associated_constant_access.rs deleted file mode 100644 index b27c1cb502..0000000000 --- a/compiler/cst/src/access/associated_constant_access.rs +++ /dev/null @@ -1,21 +0,0 @@ - -use crate::{Identifier, Node, NodeID, Type}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// An access expression to an struct constant., e.g. `u8::MAX`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct AssociatedConstant { - /// The inner struct type. - pub ty: Type, - /// The struct constant that is being accessed. - pub name: Identifier, - /// The span for the entire expression `Foo::bar()`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - - -crate::simple_node_impl!(AssociatedConstant); diff --git a/compiler/cst/src/access/associated_function_access.rs b/compiler/cst/src/access/associated_function_access.rs deleted file mode 100644 index 1d65078d88..0000000000 --- a/compiler/cst/src/access/associated_function_access.rs +++ /dev/null @@ -1,24 +0,0 @@ - - -use crate::{Expression, Identifier, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// An access expression to an associated function in a struct, e.g.`Pedersen64::hash()`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct AssociatedFunction { - /// The inner struct variant. - pub variant: Identifier, - /// The static struct member function that is being accessed. - pub name: Identifier, - /// The arguments passed to the function `name`. - pub arguments: Vec, - /// The span for the entire expression `Foo::bar()`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - - -crate::simple_node_impl!(AssociatedFunction); diff --git a/compiler/cst/src/access/member_access.rs b/compiler/cst/src/access/member_access.rs deleted file mode 100644 index c24c7c48be..0000000000 --- a/compiler/cst/src/access/member_access.rs +++ /dev/null @@ -1,22 +0,0 @@ - -use crate::{Expression, Identifier, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; -use std::fmt; - -/// A struct member access expression `inner.name` to some structure with *named members*. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct MemberAccess { - /// The inner struct that is being accessed. - pub inner: Box, - /// The name of the struct member to access. - pub name: Identifier, - /// The span covering all of `inner.name`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - - -crate::simple_node_impl!(MemberAccess); diff --git a/compiler/cst/src/access/mod.rs b/compiler/cst/src/access/mod.rs deleted file mode 100644 index 6dcf245d23..0000000000 --- a/compiler/cst/src/access/mod.rs +++ /dev/null @@ -1,16 +0,0 @@ - - -mod array_access; -pub use array_access::*; - -mod associated_constant_access; -pub use associated_constant_access::*; - -mod associated_function_access; -pub use associated_function_access::*; - -mod member_access; -pub use member_access::*; - -mod tuple_access; -pub use tuple_access::*; diff --git a/compiler/cst/src/access/tuple_access.rs b/compiler/cst/src/access/tuple_access.rs deleted file mode 100644 index 8ee4290407..0000000000 --- a/compiler/cst/src/access/tuple_access.rs +++ /dev/null @@ -1,22 +0,0 @@ - - -use crate::{Expression, Node, NodeID, NonNegativeNumber}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// A tuple access expression, e.g., `tuple.index`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct TupleAccess { - /// An expression evaluating to some tuple type, e.g., `(5, 2)`. - pub tuple: Box, - /// The index to access in the tuple expression. E.g., `0` for `(5, 2)` would yield `5`. - pub index: NonNegativeNumber, - /// The span for the entire expression `tuple.index`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - - -crate::simple_node_impl!(TupleAccess); diff --git a/compiler/cst/src/common/comment.rs b/compiler/cst/src/common/comment.rs deleted file mode 100644 index 19dba3f248..0000000000 --- a/compiler/cst/src/common/comment.rs +++ /dev/null @@ -1,8 +0,0 @@ - -use super::*; -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] - -pub enum Comment { - Line(String, #[serde(with = "leo_span::span_json")] Span, NodeID), - Block(String, #[serde(with = "leo_span::span_json")] Span, NodeID), -} \ No newline at end of file diff --git a/compiler/cst/src/common/identifier.rs b/compiler/cst/src/common/identifier.rs deleted file mode 100644 index 262eae38a8..0000000000 --- a/compiler/cst/src/common/identifier.rs +++ /dev/null @@ -1,19 +0,0 @@ -use crate::{simple_node_impl, Node, NodeID}; -use leo_span::{Span, Symbol}; - -use super::Space; - -#[derive(Clone, Copy)] -pub struct Identifier { - /// The symbol that the user wrote, e.g., `foo`. - pub pl_name: Space, - pub name: Symbol, - pub pr_name: Space, - - /// A span locating where the identifier occurred in the source. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -simple_node_impl!(Identifier); \ No newline at end of file diff --git a/compiler/cst/src/common/import_module.rs b/compiler/cst/src/common/import_module.rs deleted file mode 100644 index d5bc1f0d4c..0000000000 --- a/compiler/cst/src/common/import_module.rs +++ /dev/null @@ -1,8 +0,0 @@ -use super::Identifier; - -#[derive(Debug, Clone)] -pub struct ImportModule { - pub module: Identifier, - pub span: Span, - pub id: NodeID, -} diff --git a/compiler/cst/src/common/location.rs b/compiler/cst/src/common/location.rs deleted file mode 100644 index 3f0f02f253..0000000000 --- a/compiler/cst/src/common/location.rs +++ /dev/null @@ -1,5 +0,0 @@ -#[derive(Clone, Debug, PartialEq, Eq, Hash)] -pub struct Location { - pub program: Option, - pub name: Symbol, -} \ No newline at end of file diff --git a/compiler/cst/src/common/mod.rs b/compiler/cst/src/common/mod.rs deleted file mode 100644 index 7a36c2e80c..0000000000 --- a/compiler/cst/src/common/mod.rs +++ /dev/null @@ -1,22 +0,0 @@ -use leo_span::Span; - -pub mod comment; -pub use comment::*; - -pub mod import_module; -pub use import_module::*; - -pub mod node; -pub use node::*; - -pub mod positive_number; -pub use positive_number::*; - -pub mod location; -pub use location::*; - -pub mod identifier; -pub use identifier::*; - -pub mod space; -pub use space::*; \ No newline at end of file diff --git a/compiler/cst/src/common/node.rs b/compiler/cst/src/common/node.rs deleted file mode 100644 index a0a5080cc9..0000000000 --- a/compiler/cst/src/common/node.rs +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright (C) 2019-2023 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 . - -use leo_span::Span; - -/// A node ID. -// Development Note: -// A `NodeID` must implement: `Copy`, `Default`, among others. -pub type NodeID = usize; - -/// A node in the AST. -pub trait Node: - std::fmt::Debug + std::fmt::Display + Clone + PartialEq + Eq + serde::Serialize + serde::de::DeserializeOwned -{ - /// Returns the span of the node. - fn span(&self) -> Span; - - /// Sets the span of the node. - fn set_span(&mut self, span: Span); - - /// Returns the ID of the node. - fn id(&self) -> NodeID; - - /// Sets the ID of the node. - fn set_id(&mut self, id: NodeID); -} - -#[macro_export] -macro_rules! simple_node_impl { - ($ty:ty) => { - impl Node for $ty { - fn span(&self) -> Span { - self.span - } - - fn set_span(&mut self, span: Span) { - self.span = span; - } - - fn id(&self) -> NodeID { - self.id - } - - fn set_id(&mut self, id: NodeID) { - self.id = id; - } - } - }; -} diff --git a/compiler/cst/src/common/positive_number.rs b/compiler/cst/src/common/positive_number.rs deleted file mode 100644 index 980eda6c95..0000000000 --- a/compiler/cst/src/common/positive_number.rs +++ /dev/null @@ -1,10 +0,0 @@ -use serde::{Deserialize, Serialize}; - -/// A number string guaranteed to be non-negative. -#[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq, Hash)] -pub struct NonNegativeNumber { - /// The string representation of the non-negative number. - string: String, - /// The numeric value of the non-negative number. - value: usize, -} \ No newline at end of file diff --git a/compiler/cst/src/common/space.rs b/compiler/cst/src/common/space.rs deleted file mode 100644 index 2233179b38..0000000000 --- a/compiler/cst/src/common/space.rs +++ /dev/null @@ -1,37 +0,0 @@ -use crate::{simple_node_impl, Node, NodeID, Comment}; - -#[derive(Clone, Copy)] -pub struct Tab { - /// '\t' - /// A span locating where the identifier occurred in the source. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -#[derive(Clone, Copy)] -pub struct NewLine { - /// '\n' - /// A span locating where the identifier occurred in the source. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} -#[derive(Clone, Copy)] -pub struct WhiteSpace { - /// '\t' - /// A span locating where the identifier occurred in the source. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} -pub enum Space { - Tab(Tab), - WhiteSpace(WhiteSpace), - NewLine(NewLine), - Comment(Comment), - None -} -simple_node_impl!(WhiteSpace); -simple_node_impl!(NewLine); -simple_node_impl!(Tab); \ No newline at end of file diff --git a/compiler/cst/src/expressions/access.rs b/compiler/cst/src/expressions/access.rs deleted file mode 100644 index d10c79f248..0000000000 --- a/compiler/cst/src/expressions/access.rs +++ /dev/null @@ -1,22 +0,0 @@ - -use crate::{access::*, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// An access expressions, extracting a smaller part out of a whole. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub enum AccessExpression { - /// An `array[index]` expression. - Array(ArrayAccess), - // /// An expression accessing a range of an array. - // ArrayRange(ArrayRangeAccess), - /// Access to an associated variable of a struct e.g `u8::MAX`. - AssociatedConstant(AssociatedConstant), - /// Access to an associated function of a struct e.g `Pedersen64::hash()`. - AssociatedFunction(AssociatedFunction), - /// An expression accessing a field in a structure, e.g., `struct_var.field`. - Member(MemberAccess), - /// Access to a tuple field using its position, e.g., `tuple.1`. - Tuple(TupleAccess), -} \ No newline at end of file diff --git a/compiler/cst/src/expressions/array.rs b/compiler/cst/src/expressions/array.rs deleted file mode 100644 index 5cd3de2a2e..0000000000 --- a/compiler/cst/src/expressions/array.rs +++ /dev/null @@ -1,15 +0,0 @@ - -use super::*; -use serde::{Deserialize, Serialize}; - -/// An array expression, e.g., `[true, false, true, false]`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct ArrayExpression { - /// The elements of the array. - pub elements: Vec, - /// The span from `[` to `]`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} -crate::simple_node_impl!(ArrayExpression); diff --git a/compiler/cst/src/expressions/binary.rs b/compiler/cst/src/expressions/binary.rs deleted file mode 100644 index 0ac2d17d94..0000000000 --- a/compiler/cst/src/expressions/binary.rs +++ /dev/null @@ -1,90 +0,0 @@ - - -use super::*; -use leo_span::{sym, Symbol}; -use serde::{Deserialize, Serialize}; - -/// A binary operator. -/// -/// Precedence is defined in the parser. -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub enum BinaryOperation { - /// Addition, i.e. `+`, `.add()`. - Add, - /// Wrapping addition, i.e. `.add_wrapped()`. - AddWrapped, - /// Logical AND, i.e. `&&`. - And, - /// Bitwise AND, i.e. `&`, `.and()`. - BitwiseAnd, - /// Division, i.e. `/`, `.div()`. - Div, - /// Wrapping division, i.e. `.div_wrapped()`. - DivWrapped, - /// Equality relation, i.e. `==`, `.eq()`. - Eq, - /// Greater-or-equal relation, i.e. `>=`, `.gte()`. - Gte, - /// Greater-than relation, i.e. `>`, `.gt()`. - Gt, - /// Lesser-or-equal relation, i.e. `<=`, `.lte()`. - Lte, - /// Lesser-than relation, i.e. `<`, `.lt()`. - Lt, - /// Arithmetic modulo, i.e. `.mod()` - Mod, - /// Multiplication, i.e. `*`, `.mul()`. - Mul, - /// Wrapping multiplication, i.e. `.mul_wrapped()`. - MulWrapped, - /// Boolean NAND, i.e. `.nand()`. - Nand, - /// In-equality relation, i.e. `!=`, `.neq()`. - Neq, - /// Boolean NOR, i.e. `.nor()`. - Nor, - /// Logical OR, i.e. `||`. - Or, - /// Bitwise OR, i.e. `|`, `.or()`. - BitwiseOr, - /// Exponentiation, i.e. `**` in `a ** b`, `.pow()`. - Pow, - /// Wrapping exponentiation, i.e. `.pow_wrapped()`. - PowWrapped, - /// Remainder, i.e. `%`, `.rem()`. - Rem, - /// Wrapping remainder, i.e. `.rem_wrapped()`. - RemWrapped, - /// Shift left operation, i.e. `<<`, `.shl()`. - Shl, - /// Wrapping shift left operation, i.e. `.shl_wrapped()`. - ShlWrapped, - /// Shift right operation, i.e. >>, `.shr()`. - Shr, - /// Wrapping shift right operation, i.e. `.shr_wrapped()`. - ShrWrapped, - /// Subtraction, i.e. `-`, `.sub()`. - Sub, - /// Wrapped subtraction, i.e. `.sub_wrapped()`. - SubWrapped, - /// Bitwise XOR, i.e. `.xor()`. - Xor, -} - -/// A binary expression `left op right` of two operands separated by some operator. -/// For example, `foo + bar`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct BinaryExpression { - /// The left operand of the expression. - pub left: Box, - /// The right operand of the expression. - pub right: Box, - /// The operand defining the meaning of the resulting binary expression. - pub op: BinaryOperation, - /// The span from `left` to `right`. - pub span: Span, - /// The ID of the expression. - pub id: NodeID, -} - -crate::simple_node_impl!(BinaryExpression); diff --git a/compiler/cst/src/expressions/call.rs b/compiler/cst/src/expressions/call.rs deleted file mode 100644 index a2aeb5f7b2..0000000000 --- a/compiler/cst/src/expressions/call.rs +++ /dev/null @@ -1,23 +0,0 @@ - - -use super::*; -use leo_span::Symbol; -use serde::{Deserialize, Serialize}; - -/// A function call expression, e.g.`foo(args)` or `Foo::bar(args)`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct CallExpression { - /// An expression evaluating to a callable function, - /// either a member of a structure or a free function. - pub function: Box, // todo: make this identifier? - /// Expressions for the arguments passed to the functions parameters. - pub arguments: Vec, - /// The name of the parent program call, e.g.`bar` in `bar.aleo`. - pub program: Option, - /// Span of the entire call `function(arguments)`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(CallExpression); diff --git a/compiler/cst/src/expressions/cast.rs b/compiler/cst/src/expressions/cast.rs deleted file mode 100644 index 20a32f0218..0000000000 --- a/compiler/cst/src/expressions/cast.rs +++ /dev/null @@ -1,20 +0,0 @@ - - -use super::*; -use serde::{Deserialize, Serialize}; -use crate::Type; - -/// A cast expression, e.g. `42u8 as u16`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct CastExpression { - /// The expression to be casted, e.g.`42u8` in `42u8 as u16`. - pub expression: Box, - /// The type to be casted to, e.g. `u16` in `42u8 as u16`. - pub type_: Type, - /// Span of the entire cast `42u8 as u16`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(CastExpression); diff --git a/compiler/cst/src/expressions/err.rs b/compiler/cst/src/expressions/err.rs deleted file mode 100644 index 924c487327..0000000000 --- a/compiler/cst/src/expressions/err.rs +++ /dev/null @@ -1,15 +0,0 @@ - - -use super::*; -use serde::{Deserialize, Serialize}; - -/// Represents a syntactically invalid expression. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct ErrExpression { - /// The span of the invalid expression. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(ErrExpression); diff --git a/compiler/cst/src/expressions/literal.rs b/compiler/cst/src/expressions/literal.rs deleted file mode 100644 index 1989595c9b..0000000000 --- a/compiler/cst/src/expressions/literal.rs +++ /dev/null @@ -1,28 +0,0 @@ - - -use crate::{GroupLiteral, IntegerType}; -use serde::{Deserialize, Serialize}; -use super::*; - -/// A literal. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub enum Literal { - // todo: deserialize values here - /// An address literal, e.g., `aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8s7pyjh9` or `hello.aleo`. - Address(String, #[serde(with = "leo_span::span_json")] Span, NodeID), - /// A boolean literal, either `true` or `false`. - Boolean(bool, #[serde(with = "leo_span::span_json")] Span, NodeID), - /// A field literal, e.g., `42field`. - /// A signed number followed by the keyword `field`. - Field(String, #[serde(with = "leo_span::span_json")] Span, NodeID), - /// A group literal, either product or affine. - /// For example, `42group` or `(12, 52)group`. - Group(Box), - /// An integer literal, e.g., `42`. - Integer(IntegerType, String, #[serde(with = "leo_span::span_json")] Span, NodeID), - /// A scalar literal, e.g. `1scalar`. - /// An unsigned number followed by the keyword `scalar`. - Scalar(String, #[serde(with = "leo_span::span_json")] Span, NodeID), - /// A string literal, e.g., `"foobar"`. - String(String, #[serde(with = "leo_span::span_json")] Span, NodeID), -} diff --git a/compiler/cst/src/expressions/locator.rs b/compiler/cst/src/expressions/locator.rs deleted file mode 100644 index 09d1db802a..0000000000 --- a/compiler/cst/src/expressions/locator.rs +++ /dev/null @@ -1,22 +0,0 @@ - - -use leo_span::{Span, Symbol}; - -use crate::{simple_node_impl, Node, NodeID, ProgramId}; -use serde::{Deserialize, Serialize}; -use std::{fmt, hash::Hash}; - -/// A locator that references an external resource. -#[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub struct LocatorExpression { - /// The program that the resource is in. - pub program: ProgramId, - /// The name of the resource. - pub name: Symbol, - /// A span indicating where the locator occurred in the source. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -simple_node_impl!(LocatorExpression); diff --git a/compiler/cst/src/expressions/mod.rs b/compiler/cst/src/expressions/mod.rs deleted file mode 100644 index 508adcf505..0000000000 --- a/compiler/cst/src/expressions/mod.rs +++ /dev/null @@ -1,80 +0,0 @@ - - -use crate::{Identifier, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; -use std::fmt; - -mod access; -pub use access::*; - -mod array; -pub use array::*; - -mod binary; -pub use binary::*; - -mod call; -pub use call::*; - -mod cast; -pub use cast::*; - -mod struct_init; -pub use struct_init::*; - -mod err; -pub use err::*; - -mod ternary; -pub use ternary::*; - -mod tuple; -pub use tuple::*; - -mod unary; -pub use unary::*; - -mod unit; -pub use unit::*; - -mod literal; -pub use literal::*; - -pub mod locator; -pub use locator::*; - -/// Expression that evaluates to a value. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub enum Expression { - /// A struct access expression, e.g. `Foo.bar`. - Access(AccessExpression), - /// An array expression, e.g., `[true, false, true, false]`. - Array(ArrayExpression), - /// A binary expression, e.g., `42 + 24`. - Binary(BinaryExpression), - /// A call expression, e.g., `my_fun(args)`. - Call(CallExpression), - /// A cast expression, e.g., `42u32 as u8`. - Cast(CastExpression), - /// An expression of type "error". - /// Will result in a compile error eventually. - Err(ErrExpression), - /// An identifier. - Identifier(Identifier), - /// A literal expression. - Literal(Literal), - /// A locator expression, e.g., `hello.aleo/foo`. - Locator(LocatorExpression), - /// An expression constructing a struct like `Foo { bar: 42, baz }`. - Struct(StructExpression), - /// A ternary conditional expression `cond ? if_expr : else_expr`. - Ternary(TernaryExpression), - /// A tuple expression e.g., `(foo, 42, true)`. - Tuple(TupleExpression), - /// An unary expression. - Unary(UnaryExpression), - /// A unit expression e.g. `()` - Unit(UnitExpression), -} diff --git a/compiler/cst/src/expressions/struct_init.rs b/compiler/cst/src/expressions/struct_init.rs deleted file mode 100644 index 054cd00f0a..0000000000 --- a/compiler/cst/src/expressions/struct_init.rs +++ /dev/null @@ -1,39 +0,0 @@ - -use super::*; -use leo_span::sym; - -/// An initializer for a single field / variable of a struct initializer expression. -/// That is, in `Foo { bar: 42, baz }`, this is either `bar: 42`, or `baz`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct StructVariableInitializer { - /// The name of the field / variable to be initialized. - pub identifier: Identifier, - /// The expression to initialize the field with. - /// When `None`, a binding, in scope, with the name will be used instead. - pub expression: Option, - /// The span of the node. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(StructVariableInitializer); - -/// A struct initialization expression, e.g., `Foo { bar: 42, baz }`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct StructExpression { - /// The name of the structure type to initialize. - pub name: Identifier, - /// Initializer expressions for each of the fields in the struct. - /// - /// N.B. Any functions or member constants in the struct definition - /// are excluded from this list. - pub members: Vec, - /// A span from `name` to `}`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - - -crate::simple_node_impl!(StructExpression); diff --git a/compiler/cst/src/expressions/ternary.rs b/compiler/cst/src/expressions/ternary.rs deleted file mode 100644 index ae604a29fc..0000000000 --- a/compiler/cst/src/expressions/ternary.rs +++ /dev/null @@ -1,20 +0,0 @@ - - -use super::*; - -/// A ternary conditional expression, that is, `condition ? if_true : if_false`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct TernaryExpression { - /// The condition determining which branch to pick. - pub condition: Box, - /// The branch the expression evaluates to if `condition` evaluates to true. - pub if_true: Box, - /// The branch the expression evaluates to if `condition` evaluates to false. - pub if_false: Box, - /// The span from `condition` to `if_false`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(TernaryExpression); diff --git a/compiler/cst/src/expressions/tuple.rs b/compiler/cst/src/expressions/tuple.rs deleted file mode 100644 index 85ae868dec..0000000000 --- a/compiler/cst/src/expressions/tuple.rs +++ /dev/null @@ -1,18 +0,0 @@ - -use super::*; - -// TODO: Consider a restricted interface for constructing a tuple expression. - -/// A tuple expression, e.g., `(foo, false, 42)`. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct TupleExpression { - /// The elements of the tuple. - /// In the example above, it would be `foo`, `false`, and `42`. - pub elements: Vec, - /// The span from `(` to `)`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(TupleExpression); diff --git a/compiler/cst/src/expressions/unary.rs b/compiler/cst/src/expressions/unary.rs deleted file mode 100644 index 60bff05d6a..0000000000 --- a/compiler/cst/src/expressions/unary.rs +++ /dev/null @@ -1,43 +0,0 @@ - -use super::*; -use leo_span::{sym, Symbol}; - -/// A unary operator for a unary expression. -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub enum UnaryOperation { - /// Absolute value checking for overflow, i.e. `.abs()`. - Abs, - /// Absolute value wrapping around at the boundary of the type, i.e. `.abs_wrapped()`. - AbsWrapped, - /// Double operation, i.e. `.double()`. - Double, - /// Multiplicative inverse, i.e. `.inv()`. - Inverse, - /// Negate operation, i.e. `.neg()`. - Negate, - /// Bitwise NOT, i.e. `!`, `.not()`. - Not, - /// Square operation, i.e. `.square()`. - Square, - /// Square root operation, i.e. `.sqrt()`. - SquareRoot, - /// Converts a group element to its x-coordinate, i.e. `.to_x_coordinate()`. - ToXCoordinate, - /// Converts a group element to its y-coordinate, i.e. `.to_y_coordinate()`. - ToYCoordinate, -} - -/// An unary expression applying an operator to an inner expression. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct UnaryExpression { - /// The inner expression `op` is applied to. - pub receiver: Box, - /// The unary operator to apply to `inner`. - pub op: UnaryOperation, - /// The span covering `op inner`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(UnaryExpression); diff --git a/compiler/cst/src/expressions/unit.rs b/compiler/cst/src/expressions/unit.rs deleted file mode 100644 index 9e37ea218f..0000000000 --- a/compiler/cst/src/expressions/unit.rs +++ /dev/null @@ -1,14 +0,0 @@ - -use super::*; - -/// Represents a unit expression. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct UnitExpression { - /// The span of the unit expression. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - - -crate::simple_node_impl!(UnitExpression); diff --git a/compiler/cst/src/functions/annotation.rs b/compiler/cst/src/functions/annotation.rs deleted file mode 100644 index 518101c06e..0000000000 --- a/compiler/cst/src/functions/annotation.rs +++ /dev/null @@ -1,19 +0,0 @@ -use crate::{simple_node_impl, Identifier, Node, NodeID}; - -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// An annotation, e.g. @program. -#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] -pub struct Annotation { - // TODO: Consider using a symbol instead of an identifier. - /// The name of the annotation. - pub identifier: Identifier, - /// A span locating where the annotation occurred in the source. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -simple_node_impl!(Annotation); \ No newline at end of file diff --git a/compiler/cst/src/functions/input.rs b/compiler/cst/src/functions/input.rs deleted file mode 100644 index 881dbebc1f..0000000000 --- a/compiler/cst/src/functions/input.rs +++ /dev/null @@ -1,19 +0,0 @@ - -use crate::{Identifier, Mode, Node, NodeID, Type}; -use leo_span::Span; -use serde::{Deserialize, Serialize}; - -/// A function parameter. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct Input { - /// The name the parameter is accessible as in the function's body. - pub identifier: Identifier, - /// The mode of the function parameter. - pub mode: Mode, - /// What's the parameter's type? - pub type_: Type, - /// The parameters span from any annotations to its type. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} diff --git a/compiler/cst/src/functions/mod.rs b/compiler/cst/src/functions/mod.rs deleted file mode 100644 index e00e825430..0000000000 --- a/compiler/cst/src/functions/mod.rs +++ /dev/null @@ -1,117 +0,0 @@ -pub mod mode; -use crate::Space; - -pub use self::mode::*; - -pub mod annotation; -pub use self::annotation::*; - -pub mod input; -pub use self::input::*; - -pub mod output; -pub use self::output::*; - -pub mod variant; -pub use self::variant::*; - -use crate::{Identifier, Type, Block}; - -use serde::{Deserialize, Serialize}; -use std::fmt; - -/// A function definition. -#[derive(Clone, Serialize, Deserialize)] -pub struct Function { - /// Annotations on the function. - pub annotations: Vec, - /// Is this function a transition, inlined, or a regular function?. - pub variant: Variant, - /// The function identifier, e.g., `foo` in `function foo(...) { ... }`. - pub identifier: Identifier, - /// The function's input parameters. - pub input: Vec, - /// The function's output declarations. - pub output: Vec, - /// The function's output type. - pub output_type: Type, - /// The body of the function. - pub block: Block, - /// The entire span of the function definition. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -/* -function compute(a: u64, b: u64) -> u64 {// ===> This part will be defined in cst/src/statement/block.rs - return a + b; -} -================================================================ - -Function { - annotations: vec![], - variant: Variant::Regular, - identifier: Identifier { - pl_name: Space::None, - name: "compute", - pr_name: Space::None, - span: Span { ... }, - id: NodeID { ... }, - }, - input: vec![ - Input { - identifier: Identifier { - pl_name: Space::None, - name: "a", - pr_name: Space::None, - span: Span { ... }, - id: NodeID { ... }, - }, - mode: Mode { - pl_name: Space::None, - name: ModeEnum.None, - pr_name: Space::None, - }, - type_: Type { - pl_name: Space::WhiteSpace(WhiteSpace(....)), - name: TypeEnum::Integer(IntegerType::U64), - pr_name: Space::None, - }, - span: Span { ... }, - id: NodeID { ... }, - }, - Input { - identifier: Identifier { - pl_name: Space::WhiteSpace(WhiteSpace(....)), - name: "b", - pr_name: Space::None, - span: Span { ... }, - id: NodeID { ... }, - }, - mode: Mode { - pl_name: Space::None, - name: ModeEnum.None, - pr_name: Space::None, - }, - type_: Type { - pl_name: Space::WhiteSpace(WhiteSpace(....)), - name: TypeEnum::Integer(IntegerType::U64), - pr_name: Space::None, - }, - span: Span { ... }, - id: NodeID { ... }, - }, - ], - output: vec![], - output_type: Type { - pl_name: Space::WhiteSpace(WhiteSpace(....)), - name: TypeEnum::Integer(IntegerType::U64), - pr_name: Space::WhiteSpace(WhiteSpace(....)), - }, - block: Block { ... }, - span: Span { ... }, - id: NodeID { ... }, -} - -*/ \ No newline at end of file diff --git a/compiler/cst/src/functions/mode.rs b/compiler/cst/src/functions/mode.rs deleted file mode 100644 index 7729caf880..0000000000 --- a/compiler/cst/src/functions/mode.rs +++ /dev/null @@ -1,18 +0,0 @@ -use serde::{Deserialize, Serialize}; - -use crate::Space; - -/// The mode associated with a type. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] - -pub struct Mode { - pub pl_space: Space, - pub mode: ModeEnum, - pub pr_space: Space, -} -pub enum ModeEnum { - None, - Constant, - Private, - Public, -} \ No newline at end of file diff --git a/compiler/cst/src/functions/output.rs b/compiler/cst/src/functions/output.rs deleted file mode 100644 index d302bed557..0000000000 --- a/compiler/cst/src/functions/output.rs +++ /dev/null @@ -1,17 +0,0 @@ -use crate::{Mode, Node, NodeID, Type}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// A function output. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct Output { - /// The mode of the function output. - pub mode: Mode, - /// The type of the function output. - pub type_: Type, - /// The parameters span from any annotations to its type. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} \ No newline at end of file diff --git a/compiler/cst/src/functions/variant.rs b/compiler/cst/src/functions/variant.rs deleted file mode 100644 index 34d4678311..0000000000 --- a/compiler/cst/src/functions/variant.rs +++ /dev/null @@ -1,16 +0,0 @@ -use serde::{Deserialize, Serialize}; -#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] - -pub struct Variant { - pub pl_name: Space, - pub name: VariantEnum, - pub pr_name: Space, -} - -pub enum VariantEnum { - Inline, - Function, - Transition, - AsyncTransition, - AsyncFunction, -} \ No newline at end of file diff --git a/compiler/cst/src/lib.rs b/compiler/cst/src/lib.rs deleted file mode 100644 index 3890522b36..0000000000 --- a/compiler/cst/src/lib.rs +++ /dev/null @@ -1,32 +0,0 @@ - -pub mod program; -pub use self::program::*; - -pub mod common; -pub use self::common::*; - -pub mod mapping; -pub use self::mapping::*; - -pub mod types; -pub use self::types::*; - -pub mod r#struct; -pub use self::r#struct::*; - -pub mod functions; -pub use self::functions::*; - -pub mod statement; -pub use self::statement::*; - -pub mod access; -pub use self::access::*; - -pub mod expressions; -pub use self::expressions::*; - -#[derive(Clone, Debug, Default, Eq, PartialEq)] -pub struct Cst { - pub cst: Program, -} \ No newline at end of file diff --git a/compiler/cst/src/mapping/mod.rs b/compiler/cst/src/mapping/mod.rs deleted file mode 100644 index 87163cae66..0000000000 --- a/compiler/cst/src/mapping/mod.rs +++ /dev/null @@ -1,45 +0,0 @@ - - -use crate::{Identifier, Node, NodeID, Type}; -use serde::{Deserialize, Serialize}; -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct Mapping { - /// The name of the mapping. - pub identifier: Identifier, - /// The type of the key. - pub key_type: Type, - /// The type of the value. - pub value_type: Type, - /// The entire span of the mapping declaration. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} -crate::simple_node_impl!(Mapping); - - -/* - mapping balances: address => u64; - ========================================================================================================== - Mapping { - identifier: Identifier { - pl_name: Space::WhiteSpace(WhiteSpace { ... }), - name: "balances", - pr_name: Space::None, - span: Span { ... }, - id: NodeID { ... }, - }, - key_type: Type { - pl_name: Space::WhiteSpace(WhiteSpace { ... }), - name: TypeEnum::Address, - pr_name: Space::WhiteSpace(WhiteSpace { ... }), - }, - value_type: Type { - pl_name: Space::WhiteSpace(WhiteSpace { ... }), - name: TypeEnum::Integer(IntegerType::U64), - pr_name: Space::WhiteSpace(WhiteSpace { ... }), - }, - span: Span { ... }, - id: NodeID { ... }, - } -*/ \ No newline at end of file diff --git a/compiler/cst/src/program/mod.rs b/compiler/cst/src/program/mod.rs deleted file mode 100644 index 45bd3141d4..0000000000 --- a/compiler/cst/src/program/mod.rs +++ /dev/null @@ -1,71 +0,0 @@ - -// Copyright (C) 2019-2023 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 . - -//! A Leo program consists of import statements and program scopes. -//! - -pub mod program_scope; -pub use program_scope::*; - -pub mod program_id; -pub use program_id::*; - -use crate::{Comment, ImportModule, Space}; - -use leo_span::{Span, Symbol}; -use indexmap::IndexMap; -use serde::{Deserialize, Serialize}; -use std::fmt; - -#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] -pub struct Program { - body: Vec, -} - - -pub enum ProgramBox { - Import (ImportModule), - Space (Space), - Body (ProgramScope) -} -/* - import foo.aleo; - import hello.aleo; - - //hello - import aaa.aleo; - //hello world - /* - Test Program - */ - program abc.aleo { // this part will be defined in the program_scope.rs file - ... - } - ========================================================================================================== - - let program = Program { - body: vec![ - ProgramBox::Space(Space::Comment(Comment::Line("hello".to_string(), ...))), - ProgramBox::Import(ImportModule { ... aaa.aleo ...}), - ProgramBox::Space(Space::Comment(Comment::Line("hello world".to_string(), ...))), - ProgramBox::Space(Space::Comment(Comment::Block("Test Program".to_string(), ...))), - ProgramBox::Body(ProgramScope {...}), - ], - }; - - -*/ \ No newline at end of file diff --git a/compiler/cst/src/program/program_id.rs b/compiler/cst/src/program/program_id.rs deleted file mode 100644 index 81886e3b9b..0000000000 --- a/compiler/cst/src/program/program_id.rs +++ /dev/null @@ -1,10 +0,0 @@ -use crate::Identifier; - - -#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] -pub struct ProgramId { - /// The name of the program. - pub name: Identifier, - /// The network associated with the program. - pub network: Identifier, -} \ No newline at end of file diff --git a/compiler/cst/src/program/program_scope.rs b/compiler/cst/src/program/program_scope.rs deleted file mode 100644 index 8fd4a4719b..0000000000 --- a/compiler/cst/src/program/program_scope.rs +++ /dev/null @@ -1,58 +0,0 @@ - - -use crate::{Comment, Composite, Function, ImportModule, Mapping, NewLine, Space, Tab, WhiteSpace, ProgramId}; -use leo_span::{Span, Symbol}; - - -#[derive(Debug, Clone)] -pub struct ProgramScope { - /// The program id of the program scope. - pub program_id: ProgramId, - pub body: Vec, - pub span: Span, -} -enum ProgramBody { - Mapping(Mapping), - Struct(Composite), - Function(Function), - Const((Symbol, ConstDeclaration)), - Space(Space) -} - -/* - program abc.aleo { - mapping balances: address => u64; // ===> This part will be defined in cst/src/mapping/mod.rs - - record token { // ===> This part will be defined in cst/src/struct/mod.rs - owner: address, - amount: u64, - } - - //hello world - struct message { - sender: address, - object: u64, - } - - function compute(a: u64, b: u64) -> u64 {// ===> This part will be defined in cst/src/functions/mod.rs - return a + b; - } - } - ========================================================================================================== - ProgramScope { - program_id: ProgramId { ... }, - body: vec![ - ProgramBody::Mapping(Mapping { ... }), - ProgramBody::Space(Space::WhiteSpace(WhiteSpace { ... })), - ProgramBody::Space(Space::Comment(Comment::Line(" ===> This part will be defined in cst/src/mapping/mod.rs".to_string(), ...))), - ProgramBody::Space(Space::NewLine(NewLine { ... })), - ProgramBody::Struct(Composite { ... record token ... }), - ProgramBody::Space(Space::NewLine(NewLine { ... })), - ProgramBody::Space(Space::Comment(Comment::Line("hello world".to_string(), ...))), - ProgramBody::Struct(Composite { ... struct message ... }), - ProgramBody::Space(Space::Comment(NewLine { ... })), - ProgramBody::Function(Function { ... function compute ... }) - ], - span: Span { ... }, - } -*/ \ No newline at end of file diff --git a/compiler/cst/src/statement/assert.rs b/compiler/cst/src/statement/assert.rs deleted file mode 100644 index de0dbbf03c..0000000000 --- a/compiler/cst/src/statement/assert.rs +++ /dev/null @@ -1,28 +0,0 @@ - - -use crate::{Expression, Node, NodeID}; -use leo_span::Span; -use serde::{Deserialize, Serialize}; - -/// A variant of an assert statement. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub enum AssertVariant { - /// A `assert(expr)` variant, asserting that the expression evaluates to true. - Assert(Expression), - /// A `assert_eq(expr1, expr2)` variant, asserting that the operands are equal. - AssertEq(Expression, Expression), - /// A `assert_neq(expr1, expr2)` variant, asserting that the operands are not equal. - AssertNeq(Expression, Expression), -} - -/// An assert statement, `assert()`, `assert_eq()` or `assert_neq()`. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub struct AssertStatement { - /// The variant of the assert statement. - pub variant: AssertVariant, - /// The span, excluding the semicolon. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} -crate::simple_node_impl!(AssertStatement); diff --git a/compiler/cst/src/statement/assign.rs b/compiler/cst/src/statement/assign.rs deleted file mode 100644 index 9fa06ddc16..0000000000 --- a/compiler/cst/src/statement/assign.rs +++ /dev/null @@ -1,23 +0,0 @@ - -use crate::{Expression, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; -use std::fmt; - -/// An assignment statement, `assignee = value`. -/// Note that there is no operation associated with the assignment. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub struct AssignStatement { - /// The place to assign to. - /// Note that `place` can either be an identifier or tuple. - pub place: Expression, - /// The value to assign to the `assignee`. - pub value: Expression, - /// The span, excluding the semicolon. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(AssignStatement); diff --git a/compiler/cst/src/statement/block.rs b/compiler/cst/src/statement/block.rs deleted file mode 100644 index 779f861d42..0000000000 --- a/compiler/cst/src/statement/block.rs +++ /dev/null @@ -1,63 +0,0 @@ - - -use crate::{Comment, Node, NodeID, Space, Statement}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// A block `{ [stmt]* }` consisting of a list of statements to execute in order. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug, Default)] -pub struct Block { - /// The list of statements to execute. - pub body: Vec, - /// The span from `{` to `}`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, - -} -enum BlockBody { - Space(Space), - Statement(Statement), -} - -crate::simple_node_impl!(Block); - -/* - function compute(a: u64, b: u64) -> u64 {// ===> This part will be defined in cst/src/statement/block.rs - return a + b; - } -================================================ - block: { - body: vec![ - BlockBody::Space(Space::Comment(Comment::Line("This part will be defined in cst/src/statement/block.rs", ...))) - BlockBody::Statement(Statement::Return { - value: Expression::Binary { - left: Expression::Identifier { - identifier: Identifier { - pl_name: Space::None, - name: "a", - pr_name: Space::WhiteSpace(WhiteSpace(....)), - span: Span { ... }, - id: NodeID { ... }, - }, - operator: Operator::Plus, - right: Expression::Identifier { - identifier: Identifier { - pl_name: Space::WhiteSpace(WhiteSpace(....)), - name: "b", - pr_name: Space::None, - span: Span { ... }, - id: NodeID { ... }, - }, - }, - }, - }), - }), - ], - span: Span { ... }, - id: NodeID { ... }, - }, - - -*/ \ No newline at end of file diff --git a/compiler/cst/src/statement/conditional.rs b/compiler/cst/src/statement/conditional.rs deleted file mode 100644 index 6767f9b8df..0000000000 --- a/compiler/cst/src/statement/conditional.rs +++ /dev/null @@ -1,24 +0,0 @@ - - -use crate::{Block, Expression, Node, NodeID, Statement}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; -use std::fmt; - -/// An `if condition block (else next)?` statement. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub struct ConditionalStatement { - /// The `bool`-typed condition deciding what to evaluate. - pub condition: Expression, - /// The block to evaluate in case `condition` yields `true`. - pub then: Block, - /// The statement, if any, to evaluate when `condition` yields `false`. - pub otherwise: Option>, - /// The span from `if` to `next` or to `block`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(ConditionalStatement); diff --git a/compiler/cst/src/statement/console/console_function.rs b/compiler/cst/src/statement/console/console_function.rs deleted file mode 100644 index e71c2894b0..0000000000 --- a/compiler/cst/src/statement/console/console_function.rs +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (C) 2019-2023 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 . - -use crate::Expression; - -use serde::{Deserialize, Serialize}; -use std::fmt; - -/// A console logging function to invoke. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub enum ConsoleFunction { - /// A `console.assert(expr)` call to invoke, asserting that the expression evaluates to true. - Assert(Expression), - /// A `console.assert_eq(expr1, expr2)` call to invoke, asserting that the operands are equal. - AssertEq(Expression, Expression), - /// A `console.assert_neq(expr1, expr2)` call to invoke, asserting that the operands are not equal. - AssertNeq(Expression, Expression), -} - -impl fmt::Display for ConsoleFunction { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self { - ConsoleFunction::Assert(expr) => write!(f, "assert({expr})"), - ConsoleFunction::AssertEq(expr1, expr2) => write!(f, "assert_eq({expr1}, {expr2})"), - ConsoleFunction::AssertNeq(expr1, expr2) => write!(f, "assert_neq({expr1}, {expr2})"), - } - } -} diff --git a/compiler/cst/src/statement/console/console_statement.rs b/compiler/cst/src/statement/console/console_statement.rs deleted file mode 100644 index f305510a32..0000000000 --- a/compiler/cst/src/statement/console/console_statement.rs +++ /dev/null @@ -1,46 +0,0 @@ -// Copyright (C) 2019-2023 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 . - -use crate::{ConsoleFunction, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; -use std::fmt; - -/// A console logging statement like `console.log(...);`. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct ConsoleStatement { - /// The logging function to run. - pub function: ConsoleFunction, - /// The span excluding the semicolon. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -impl fmt::Display for ConsoleStatement { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "console.{};", self.function) - } -} - -impl fmt::Debug for ConsoleStatement { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "console.{};", self.function) - } -} - -crate::simple_node_impl!(ConsoleStatement); diff --git a/compiler/cst/src/statement/console/mod.rs b/compiler/cst/src/statement/console/mod.rs deleted file mode 100644 index 02dec1bb1c..0000000000 --- a/compiler/cst/src/statement/console/mod.rs +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright (C) 2019-2023 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 . - -pub mod console_function; -pub use console_function::*; - -pub mod console_statement; -pub use console_statement::*; diff --git a/compiler/cst/src/statement/const_.rs b/compiler/cst/src/statement/const_.rs deleted file mode 100644 index 66e47f0338..0000000000 --- a/compiler/cst/src/statement/const_.rs +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright (C) 2019-2023 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 . - -use crate::{Expression, Identifier, Node, NodeID, Type}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// A constant declaration statement. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub struct ConstDeclaration { - /// The place to assign to. As opposed to `DefinitionStatement`, this can only be an identifier - pub place: Identifier, - /// The type of the binding, if specified, or inferred otherwise. - pub type_: Type, - /// An initializer value for the binding. - pub value: Expression, - /// The span excluding the semicolon. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(ConstDeclaration); diff --git a/compiler/cst/src/statement/definition/mod.rs b/compiler/cst/src/statement/definition/mod.rs deleted file mode 100644 index aaf67a5202..0000000000 --- a/compiler/cst/src/statement/definition/mod.rs +++ /dev/null @@ -1,52 +0,0 @@ -// Copyright (C) 2019-2023 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 . - -use crate::{Expression, Node, NodeID, Type}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; -use std::fmt; - -mod declaration_type; -pub use declaration_type::*; - -/// A `let` or `const` declaration statement. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub struct DefinitionStatement { - /// What sort of declaration is this? `let` or `const`?. - pub declaration_type: DeclarationType, - /// The bindings / variable names to declare. - pub place: Expression, - /// The types of the bindings, if specified, or inferred otherwise. - pub type_: Type, - /// An initializer value for the bindings. - pub value: Expression, - /// The span excluding the semicolon. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -impl fmt::Display for DefinitionStatement { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{} ", self.declaration_type)?; - write!(f, "{}", self.place)?; - write!(f, ": {}", self.type_)?; - write!(f, " = {};", self.value) - } -} - -crate::simple_node_impl!(DefinitionStatement); diff --git a/compiler/cst/src/statement/expression.rs b/compiler/cst/src/statement/expression.rs deleted file mode 100644 index 008d6b6814..0000000000 --- a/compiler/cst/src/statement/expression.rs +++ /dev/null @@ -1,18 +0,0 @@ - -use crate::{Expression, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// An expression statement, `foo(a);`. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub struct ExpressionStatement { - /// The expression associated with the statement. - pub expression: Expression, - /// The span. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(ExpressionStatement); diff --git a/compiler/cst/src/statement/iteration.rs b/compiler/cst/src/statement/iteration.rs deleted file mode 100644 index f5f573fe77..0000000000 --- a/compiler/cst/src/statement/iteration.rs +++ /dev/null @@ -1,37 +0,0 @@ - -use crate::{Block, Expression, Identifier, Node, NodeID, Type, Value}; - -use leo_span::Span; - -use serde::{Deserialize, Serialize}; -use std::{cell::RefCell, fmt}; - -/// A bounded `for` loop statement `for variable in start .. =? stop block`. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub struct IterationStatement { - /// The binding / variable to introduce in the body `block`. - pub variable: Identifier, - /// The type of the iteration. - pub type_: Type, - /// The start of the iteration. - pub start: Expression, - /// The concrete value of `start`. - #[serde(skip)] - pub start_value: RefCell>, - /// The end of the iteration, possibly `inclusive`. - pub stop: Expression, - /// The concrete value of `stop`. - #[serde(skip)] - pub stop_value: RefCell>, - /// Whether `stop` is inclusive or not. - /// Signified with `=` when parsing. - pub inclusive: bool, - /// The block to run on each iteration. - pub block: Block, - /// The span from `for` to `block`. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(IterationStatement); diff --git a/compiler/cst/src/statement/mod.rs b/compiler/cst/src/statement/mod.rs deleted file mode 100644 index bfd4d0b88e..0000000000 --- a/compiler/cst/src/statement/mod.rs +++ /dev/null @@ -1,62 +0,0 @@ - - -pub mod assert; -pub use assert::*; - -pub mod assign; -pub use assign::*; - -pub mod block; -pub use block::*; - -pub mod conditional; -pub use conditional::*; - -pub mod console; -pub use console::*; - -pub mod const_; -pub use const_::*; - -pub mod definition; -pub use definition::*; - -pub mod expression; -pub use expression::*; - -pub mod iteration; -pub use iteration::*; - -pub mod return_; -pub use return_::*; - -use crate::{Node, NodeID}; - -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// Program statement that defines some action (or expression) to be carried out. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub enum Statement { - /// An assert statement. - Assert(AssertStatement), - /// An assignment statement. - Assign(Box), - /// A block statement. - Block(Block), - /// An `if` statement. - Conditional(ConditionalStatement), - /// A console logging statement. - Console(ConsoleStatement), - /// A binding from identifier to constant value. - Const(ConstDeclaration), - /// A binding or set of bindings / variables to declare. - Definition(DefinitionStatement), - /// An expression statement - Expression(ExpressionStatement), - /// A `for` statement. - Iteration(Box), - /// A return statement `return expr;`. - Return(ReturnStatement), -} diff --git a/compiler/cst/src/statement/return_.rs b/compiler/cst/src/statement/return_.rs deleted file mode 100644 index c77244d0a3..0000000000 --- a/compiler/cst/src/statement/return_.rs +++ /dev/null @@ -1,19 +0,0 @@ - - -use crate::{Expression, Node, NodeID}; -use leo_span::Span; - -use serde::{Deserialize, Serialize}; - -/// A return statement `return expression;`. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] -pub struct ReturnStatement { - /// The expression to return to the function caller. - pub expression: Expression, - /// The span of `return expression` excluding the semicolon. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} - -crate::simple_node_impl!(ReturnStatement); diff --git a/compiler/cst/src/struct/member.rs b/compiler/cst/src/struct/member.rs deleted file mode 100644 index a2a8cce1fe..0000000000 --- a/compiler/cst/src/struct/member.rs +++ /dev/null @@ -1,40 +0,0 @@ -use crate::{Identifier, Mode, Node, NodeID, Type, Space}; - -use leo_span::{Span, Symbol}; - -use serde::{Deserialize, Serialize}; - -/// A member of a structured data type, e.g `foobar: u8` or `private baz: bool` . -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct Member { - /// The mode of the member. - pub mode: Mode, - /// The identifier of the member. - pub identifier: Identifier, - /// The type of the member. - pub type_: Type, - /// The span of the member. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} -crate::simple_node_impl!(Member); - -/* - owner: address, - ======================== - Member { - mode: Mode::Public, - identifier: Identifier { - pl_name: Space::WhiteSpace(WhiteSpace { ... }), - name: "owner", - pr_name: Space::None, - span: Span { ... }, - id: NodeID { ... }, - }, - type_: Type::Address, - span: Span { ... }, - id: NodeID { ... }, - } - -*/ \ No newline at end of file diff --git a/compiler/cst/src/struct/mod.rs b/compiler/cst/src/struct/mod.rs deleted file mode 100644 index 10cf470a6a..0000000000 --- a/compiler/cst/src/struct/mod.rs +++ /dev/null @@ -1,81 +0,0 @@ -pub mod member; -pub use member::*; - -use crate::{Identifier, Mode, Node, NodeID, Space, Type}; -use serde::{Deserialize, Serialize}; -#[derive(Clone, Serialize, Deserialize)] -pub struct Composite { - /// The name of the type in the type system in this module. - pub identifier: Identifier, - /// The fields, constant variables, and functions of this structure. - pub body: Vec, - /// The external program the struct is defined in. - pub external: Option, - /// Was this a `record Foo { ... }`? - /// If so, it wasn't a composite. - pub is_record: bool, - /// The entire span of the composite definition. - pub span: Span, - /// The ID of the node. - pub id: NodeID, -} -enum CompositeBody { - Member(Member), - Space(Space), -} -crate::simple_node_impl!(Composite); - - -/* - record token { // ===> This part will be defined in member.rs - owner: address, - - //amount value - amount: u64, - } - - ========================================================================================================== - Composite { - identifier: Identifier { - pl_name: Space::WhiteSpace(WhiteSpace { ... }), - name: "token", - pr_name: Space::WhiteSpace(WhiteSpace { ... }), - span: Span { ... }, - id: NodeID { ... }, - }, - body: vec![ - Member { - mode: Mode::Public, - identifier: Identifier { - pl_name: Space::WhiteSpace(WhiteSpace { ... }), - name: "owner", - pr_name: Space::None, - span: Span { ... }, - id: NodeID { ... }, - }, - type_: Type::Address, - span: Span { ... }, - id: NodeID { ... }, - }, - Space::NewLine(NewLine { ... }), - Space::Comment(Comment::Line("amount value", ...)), - Member { - mode: Mode::Public, - identifier: Identifier { - pl_name: Space::WhiteSpace(WhiteSpace { ... }), - name: "amount", - pr_name: Space::None, - span: Span { ... }, - id: NodeID { ... }, - }, - type_: Type::U64, - span: Span { ... }, - id: NodeID { ... }, - }, - ] - external: None, - is_record: true, - span: Span { ... }, - id: NodeID { ... }, - } -*/ diff --git a/compiler/cst/src/types/array.rs b/compiler/cst/src/types/array.rs deleted file mode 100644 index cb8e8c9683..0000000000 --- a/compiler/cst/src/types/array.rs +++ /dev/null @@ -1,8 +0,0 @@ -use crate::{NonNegativeNumber, Type}; -use serde::{Deserialize, Serialize}; -/// An array type. -#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub struct ArrayType { - element_type: Box, - length: NonNegativeNumber, -} \ No newline at end of file diff --git a/compiler/cst/src/types/core_constant.rs b/compiler/cst/src/types/core_constant.rs deleted file mode 100644 index 423358af0e..0000000000 --- a/compiler/cst/src/types/core_constant.rs +++ /dev/null @@ -1,5 +0,0 @@ -/// A core constant that maps directly to an AVM bytecode constant. -#[derive(Clone, PartialEq, Eq)] -pub enum CoreConstant { - GroupGenerator, -} diff --git a/compiler/cst/src/types/future.rs b/compiler/cst/src/types/future.rs deleted file mode 100644 index 37e9619bb4..0000000000 --- a/compiler/cst/src/types/future.rs +++ /dev/null @@ -1,13 +0,0 @@ -use crate::{Location, Type}; -use serde::{Deserialize, Serialize}; - -/// A future type consisting of the type of the inputs. -#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub struct FutureType { - // Optional type specification of inputs. - pub inputs: Vec, - // The location of the function that produced the future. - pub location: Option, - // Whether or not the type has been explicitly specified. - pub is_explicit: bool, -} \ No newline at end of file diff --git a/compiler/cst/src/types/integer_type.rs b/compiler/cst/src/types/integer_type.rs deleted file mode 100644 index 3cfc34be5b..0000000000 --- a/compiler/cst/src/types/integer_type.rs +++ /dev/null @@ -1,17 +0,0 @@ - -use serde::{Deserialize, Serialize}; -/// Explicit integer type. -#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub enum IntegerType { - U8, - U16, - U32, - U64, - U128, - - I8, - I16, - I32, - I64, - I128, -} \ No newline at end of file diff --git a/compiler/cst/src/types/mapping.rs b/compiler/cst/src/types/mapping.rs deleted file mode 100644 index 37df1d0a13..0000000000 --- a/compiler/cst/src/types/mapping.rs +++ /dev/null @@ -1,12 +0,0 @@ -use crate::Type; - -use leo_span::Symbol; -use serde::{Deserialize, Serialize}; - -/// A mapping type of a key and value type. -#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub struct MappingType { - pub key: Box, - pub value: Box, - pub program: Symbol, -} \ No newline at end of file diff --git a/compiler/cst/src/types/mod.rs b/compiler/cst/src/types/mod.rs deleted file mode 100644 index 5ca4f20460..0000000000 --- a/compiler/cst/src/types/mod.rs +++ /dev/null @@ -1,23 +0,0 @@ -pub mod array; -pub use array::*; - -pub mod core_constant; -pub use core_constant::*; - -pub mod future; -pub use future::*; - -pub mod integer_type; -pub use integer_type::*; - -pub mod mapping; -pub use mapping::*; - -pub mod struct_type; -pub use struct_type::*; - -pub mod tuple; -pub use tuple::*; - -pub mod type_; -pub use type_::*; \ No newline at end of file diff --git a/compiler/cst/src/types/struct_type.rs b/compiler/cst/src/types/struct_type.rs deleted file mode 100644 index 1bc90dce6a..0000000000 --- a/compiler/cst/src/types/struct_type.rs +++ /dev/null @@ -1,14 +0,0 @@ - -use crate::Identifier; - -use leo_span::Symbol; -use serde::{Deserialize, Serialize}; - -/// A composite type of a identifier and external program name. -#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Copy)] -pub struct CompositeType { - // The identifier of the composite definition. - pub id: Identifier, - // The external program that this composite is defined in. - pub program: Option, -} \ No newline at end of file diff --git a/compiler/cst/src/types/tuple.rs b/compiler/cst/src/types/tuple.rs deleted file mode 100644 index 92c409b020..0000000000 --- a/compiler/cst/src/types/tuple.rs +++ /dev/null @@ -1,9 +0,0 @@ -use crate::Type; - -use serde::{Deserialize, Serialize}; - -/// A type list of at least two types. -#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] -pub struct TupleType { - elements: Vec, -} \ No newline at end of file diff --git a/compiler/cst/src/types/type_.rs b/compiler/cst/src/types/type_.rs deleted file mode 100644 index 97d9bba1c5..0000000000 --- a/compiler/cst/src/types/type_.rs +++ /dev/null @@ -1,44 +0,0 @@ -use crate::{common, ArrayType, CompositeType, FutureType, Identifier, IntegerType, MappingType, Space, TupleType}; - -#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] - -pub struct Type { - pub pl_name: Space, - name: TypeEnum, - pub pr_name: Space, -} -pub enum TypeEnum { - /// The `address` type. - Address, - /// The array type. - Array(ArrayType), - /// The `bool` type. - Boolean, - /// The `struct` type. - Composite(CompositeType), - /// The `field` type. - Field, - /// The `future` type. - Future(FutureType), - /// The `group` type. - Group, - /// A reference to a built in type. - Identifier(Identifier), - /// An integer type. - Integer(IntegerType), - /// A mapping type. - Mapping(MappingType), - /// The `scalar` type. - Scalar, - /// The `signature` type. - Signature, - /// The `string` type. - String, - /// A static tuple of at least one type. - Tuple(TupleType), - /// The `unit` type. - Unit, - /// Placeholder for a type that could not be resolved or was not well-formed. - /// Will eventually lead to a compile error. - Err, -} \ No newline at end of file diff --git a/compiler/parser/src/lib.rs b/compiler/parser/src/lib.rs index abe8a9a928..6b838a6fae 100644 --- a/compiler/parser/src/lib.rs +++ b/compiler/parser/src/lib.rs @@ -31,7 +31,7 @@ pub(crate) use tokenizer::*; pub mod parser; pub use parser::*; -use leo_ast::{Ast, NodeBuilder}; +use leo_ast::{Ast, Cst, NodeBuilder}; use leo_errors::{emitter::Handler, Result}; use snarkvm::prelude::Network; @@ -48,3 +48,13 @@ pub fn parse_ast( ) -> Result { Ok(Ast::new(parse::(handler, node_builder, source, start_pos)?)) } + +/// Creates a new CST from a given file path and source code text. +pub fn parse_cst( + handler: &Handler, + node_builder: &NodeBuilder, + source: &str, + start_pos: BytePos, +) -> Result { + Ok(Cst::new(parse_::(handler, node_builder, source, start_pos)?)) +} \ No newline at end of file diff --git a/compiler/parser/src/parser/context.rs b/compiler/parser/src/parser/context.rs index 3e2db39f7d..d035ea0270 100644 --- a/compiler/parser/src/parser/context.rs +++ b/compiler/parser/src/parser/context.rs @@ -72,6 +72,24 @@ impl<'a, N: Network> ParserContext<'a, N> { p.bump(); p } + pub fn new_cst(handler: &'a Handler, node_builder: &'a NodeBuilder, mut tokens: Vec) -> Self { + // For performance we reverse so that we get cheap `.pop()`s. + tokens.reverse(); + + let token = SpannedToken::dummy(); + let mut p = Self { + handler, + node_builder, + disallow_struct_construction: false, + prev_token: token.clone(), + token, + tokens, + program_name: None, + phantom: Default::default(), + }; + p.bump(); + p + } /// Advances the parser cursor by one token. /// diff --git a/compiler/parser/src/parser/file.rs b/compiler/parser/src/parser/file.rs index 1a6e4c64d9..a94cb51488 100644 --- a/compiler/parser/src/parser/file.rs +++ b/compiler/parser/src/parser/file.rs @@ -57,6 +57,55 @@ impl ParserContext<'_, N> { Ok(Program { imports, stubs: IndexMap::new(), program_scopes }) } + + pub fn parse_program_cst(&mut self) -> Result { + let mut imports = IndexMap::new(); + let mut program_scopes = IndexMap::new(); + let mut comments = vec![]; + // TODO: Remove restrictions on multiple program scopes + let mut parsed_program_scope = false; + let mut index: usize = 0; + while self.has_next() { + match &self.token.token { + Token::Import => { + let (id, import) = self.parse_import_cst()?; + imports.insert(id, (import.0, import.1, index)); + index = index + 1; + } + Token::Program => { + match parsed_program_scope { + // Only one program scope is allowed per file. + true => { + return Err(ParserError::only_one_program_scope_is_allowed(self.token.span).into()); + } + false => { + parsed_program_scope = true; + let program_scope = self.parse_program_scope()?; + program_scopes.insert(program_scope.program_id.name.name, (program_scope, index)); + index = index + 1; + } + } + } + Token::CommentLine(string) => { + comments.push((Comment::CommentLine(string.clone()), index)); + index = index + 1; + self.bump(); + } + Token::CommentBlock(string) => { + comments.push((Comment::CommentBlock(string.clone()), index)); + index = index + 1; + self.bump(); + } + _ => return Err(Self::unexpected_item(&self.token, &[Token::Import, Token::Program]).into()), + } + } + + // Requires that at least one program scope is present. + if !parsed_program_scope { + return Err(ParserError::missing_program_scope(self.token.span).into()); + } + Ok(CSTProgram { imports, stubs: IndexMap::new(), program_scopes, comments}) + } fn unexpected_item(token: &SpannedToken, expected: &[Token]) -> ParserError { ParserError::unexpected( @@ -90,6 +139,28 @@ impl ParserContext<'_, N> { Ok((import_name.name, (Program::default(), start + end))) } + pub(super) fn parse_import_cst(&mut self) -> Result<(Symbol, (CSTProgram, Span))> { + // Parse `import`. + let start = self.expect(&Token::Import)?; + + // Parse `foo`. + let import_name = self.expect_identifier()?; + + // Parse `.`. + self.expect(&Token::Dot)?; + + // Parse network, which currently must be `aleo`. + if !self.eat(&Token::Aleo) { + // Throw error for non-aleo networks. + return Err(ParserError::invalid_network(self.token.span).into()); + } + + let end = self.expect(&Token::Semicolon)?; + + // Return the import name and the span. + Ok((import_name.name, (CSTProgram::default(), start + end))) + } + /// Parses a program scope `program foo.aleo { ... }`. fn parse_program_scope(&mut self) -> Result { // Parse `program` keyword. diff --git a/compiler/parser/src/parser/mod.rs b/compiler/parser/src/parser/mod.rs index 33e350a893..063b0a916f 100644 --- a/compiler/parser/src/parser/mod.rs +++ b/compiler/parser/src/parser/mod.rs @@ -49,3 +49,14 @@ pub fn parse( tokens.parse_program() } + +pub fn parse_( + handler: &Handler, + node_builder: &NodeBuilder, + source: &str, + start_pos: BytePos, +) -> Result { + let mut tokens = ParserContext::::new_cst(handler, node_builder, crate::tokenize(source, start_pos)?); + + tokens.parse_program_cst() +} \ No newline at end of file