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

Add NodeID to Literal

Browse Source
This commit is contained in:
Pranav Gaddamadugu 2023-08-09 10:46:06 -04:00
parent ec3aa4bd75
commit 5a1b9efd80
8 changed files with 119 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
compiler/ast/src/common/global_consts_json.rs
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>. // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::{DefinitionStatement, Identifier}; use crate::{DefinitionStatement, Identifier, NodeID};
use leo_span::Symbol; use leo_span::Symbol;
@ -36,6 +36,7 @@ pub fn serialize<S: Serializer>(
joined.serialize(serializer) joined.serialize(serializer)
} }
// TODO (@d0cd) Fix serialization to be compatible with NodeID.
pub fn deserialize<'de, D: Deserializer<'de>>( pub fn deserialize<'de, D: Deserializer<'de>>(
deserializer: D, deserializer: D,
) -> Result<IndexMap<Vec<Identifier>, DefinitionStatement>, D::Error> { ) -> Result<IndexMap<Vec<Identifier>, DefinitionStatement>, D::Error> {
@ -44,7 +45,11 @@ pub fn deserialize<'de, D: Deserializer<'de>>(
.map(|(name, program)| { .map(|(name, program)| {
( (
name.split(',') name.split(',')
.map(|ident_name| Identifier { name: Symbol::intern(ident_name), span: Default::default() }) .map(|ident_name| Identifier {
name: Symbol::intern(ident_name),
span: Default::default(),
id: NodeID::default(),
})
.collect::<Vec<Identifier>>(), .collect::<Vec<Identifier>>(),
program, program,
) )

9
compiler/ast/src/common/identifier.rs
View File

@ -54,7 +54,7 @@ simple_node_impl!(Identifier);
impl Identifier { impl Identifier {
/// Constructs a new identifier with `name` and a default span. /// Constructs a new identifier with `name` and a default span.
pub fn new(name: Symbol) -> Self { pub fn new(name: Symbol) -> Self {
Self { name, span: Span::default() } Self { name, span: Span::default(), id: NodeID::default() }
} }
/// Check if the Identifier name matches the other name. /// Check if the Identifier name matches the other name.
@ -139,7 +139,12 @@ impl<'de> Deserialize<'de> for Identifier {
None => return Err(E::custom("missing 'span' in serialized Identifier struct")), None => return Err(E::custom("missing 'span' in serialized Identifier struct")),
}; };
Ok(Identifier { name, span }) let id: NodeID = match key.get("id") {
Some(id) => to_json_string(id)?,
None => return Err(E::custom("missing 'id' in serialized Identifier struct")),
};
Ok(Identifier { name, span, id })
} }
} }

78
compiler/ast/src/expressions/literal.rs
View File

@ -24,34 +24,34 @@ use super::*;
pub enum Literal { pub enum Literal {
// todo: deserialize values here // todo: deserialize values here
/// An address literal, e.g., `aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8s7pyjh9`. /// An address literal, e.g., `aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8s7pyjh9`.
Address(String, #[serde(with = "leo_span::span_json")] Span), Address(String, #[serde(with = "leo_span::span_json")] Span, NodeID),
/// A boolean literal, either `true` or `false`. /// A boolean literal, either `true` or `false`.
Boolean(bool, #[serde(with = "leo_span::span_json")] Span), Boolean(bool, #[serde(with = "leo_span::span_json")] Span, NodeID),
/// A field literal, e.g., `42field`. /// A field literal, e.g., `42field`.
/// A signed number followed by the keyword `field`. /// A signed number followed by the keyword `field`.
Field(String, #[serde(with = "leo_span::span_json")] Span), Field(String, #[serde(with = "leo_span::span_json")] Span, NodeID),
/// A group literal, either product or affine. /// A group literal, either product or affine.
/// For example, `42group` or `(12, 52)group`. /// For example, `42group` or `(12, 52)group`.
Group(Box<GroupLiteral>), Group(Box<GroupLiteral>),
/// An integer literal, e.g., `42`. /// An integer literal, e.g., `42`.
Integer(IntegerType, String, #[serde(with = "leo_span::span_json")] Span), Integer(IntegerType, String, #[serde(with = "leo_span::span_json")] Span, NodeID),
/// A scalar literal, e.g. `1scalar`. /// A scalar literal, e.g. `1scalar`.
/// An unsigned number followed by the keyword `scalar`. /// An unsigned number followed by the keyword `scalar`.
Scalar(String, #[serde(with = "leo_span::span_json")] Span), Scalar(String, #[serde(with = "leo_span::span_json")] Span, NodeID),
/// A string literal, e.g., `"foobar"`. /// A string literal, e.g., `"foobar"`.
String(String, #[serde(with = "leo_span::span_json")] Span), String(String, #[serde(with = "leo_span::span_json")] Span, NodeID),
} }
impl fmt::Display for Literal { impl fmt::Display for Literal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match &self { match &self {
Self::Address(address, _) => write!(f, "{address}"), Self::Address(address, _, _) => write!(f, "{address}"),
Self::Boolean(boolean, _) => write!(f, "{boolean}"), Self::Boolean(boolean, _, _) => write!(f, "{boolean}"),
Self::Field(field, _) => write!(f, "{field}field"), Self::Field(field, _, _) => write!(f, "{field}field"),
Self::Group(group) => write!(f, "{group}group"), Self::Group(group) => write!(f, "{group}group"),
Self::Integer(type_, value, _) => write!(f, "{value}{type_}"), Self::Integer(type_, value, _, _) => write!(f, "{value}{type_}"),
Self::Scalar(scalar, _) => write!(f, "{scalar}scalar"), Self::Scalar(scalar, _, _) => write!(f, "{scalar}scalar"),
Self::String(string, _) => write!(f, "\"{string}\""), Self::String(string, _, _) => write!(f, "\"{string}\""),
} }
} }
} }
@ -59,39 +59,49 @@ impl fmt::Display for Literal {
impl Node for Literal { impl Node for Literal {
fn span(&self) -> Span { fn span(&self) -> Span {
match &self { match &self {
Self::Address(_, span) Self::Address(_, span, _)
| Self::Boolean(_, span) | Self::Boolean(_, span, _)
| Self::Field(_, span) | Self::Field(_, span, _)
| Self::Integer(_, _, span) | Self::Integer(_, _, span, _)
| Self::Scalar(_, span) | Self::Scalar(_, span, _)
| Self::String(_, span) => *span, | Self::String(_, span, _) => *span,
Self::Group(group) => match &**group { Self::Group(group) => *group.span(),
GroupLiteral::Single(_, span) => *span,
GroupLiteral::Tuple(tuple) => tuple.span,
},
} }
} }
fn set_span(&mut self, new_span: Span) { fn set_span(&mut self, new_span: Span) {
match self { match self {
Self::Address(_, span) Self::Address(_, span, _)
| Self::Boolean(_, span) | Self::Boolean(_, span, _)
| Self::Field(_, span) | Self::Field(_, span, _)
| Self::Integer(_, _, span) | Self::Integer(_, _, span, _)
| Self::Scalar(_, span) | Self::Scalar(_, span, _)
| Self::String(_, span) => *span = new_span, | Self::String(_, span, _) => *span = new_span,
Self::Group(group) => match &mut **group { Self::Group(group) => group.set_span(new_span),
GroupLiteral::Single(_, span) => *span = new_span,
GroupLiteral::Tuple(tuple) => tuple.span = new_span,
},
} }
} }
fn id(&self) -> NodeID { fn id(&self) -> NodeID {
todo!() match &self {
Self::Address(_, _, id)
| Self::Boolean(_, _, id)
| Self::Field(_, _, id)
| Self::Integer(_, _, _, id)
| Self::Scalar(_, _, id)
| Self::String(_, _, id) => *id,
Self::Group(group) => *group.id(),
}
} }
fn set_id(&mut self, id: NodeID) { fn set_id(&mut self, id: NodeID) {
todo!() match self {
Self::Address(_, _, old_id)
| Self::Boolean(_, _, old_id)
| Self::Field(_, _, old_id)
| Self::Integer(_, _, _, old_id)
| Self::Scalar(_, _, old_id)
| Self::String(_, _, old_id) => *old_id = id,
Self::Group(group) => group.set_id(id),
}
} }
} }

2
compiler/ast/src/functions/finalize.rs
View File

@ -49,7 +49,7 @@ impl Finalize {
_ => Type::Tuple(Tuple(output.iter().map(|output| output.type_()).collect())), _ => Type::Tuple(Tuple(output.iter().map(|output| output.type_()).collect())),
}; };
Self { identifier, input, output, output_type, block, span } Self { identifier, input, output, output_type, block, span, id: NodeID::default() }
} }
} }

13
compiler/ast/src/functions/mod.rs
View File

@ -102,7 +102,18 @@ impl Function {
_ => Type::Tuple(Tuple(output.iter().map(|output| get_output_type(output)).collect())), _ => Type::Tuple(Tuple(output.iter().map(|output| get_output_type(output)).collect())),
}; };
Function { annotations, variant, identifier, input, output, output_type, block, finalize, span } Function {
annotations,
variant,
identifier,
input,
output,
output_type,
block,
finalize,
span,
id: NodeID::default(),
}
} }
/// Returns function name. /// Returns function name.

27
compiler/ast/src/groups/group_literal.rs
View File

@ -14,7 +14,8 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>. // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::groups::GroupCoordinate; use crate::{groups::GroupCoordinate, NodeID};
use leo_span::Span; use leo_span::Span;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
@ -24,7 +25,7 @@ use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum GroupLiteral { pub enum GroupLiteral {
/// Product group literal, e.g., `42group`. /// Product group literal, e.g., `42group`.
Single(String, #[serde(with = "leo_span::span_json")] Span), Single(String, #[serde(with = "leo_span::span_json")] Span, NodeID),
/// An affine group literal with (x, y) coordinates. /// An affine group literal with (x, y) coordinates.
Tuple(GroupTuple), Tuple(GroupTuple),
} }
@ -32,23 +33,37 @@ pub enum GroupLiteral {
impl GroupLiteral { impl GroupLiteral {
pub fn set_span(&mut self, new_span: Span) { pub fn set_span(&mut self, new_span: Span) {
match self { match self {
Self::Single(_, old_span) => *old_span = new_span, Self::Single(_, old_span, _) => *old_span = new_span,
Self::Tuple(tuple) => tuple.span = new_span, Self::Tuple(tuple) => tuple.span = new_span,
} }
} }
pub fn span(&self) -> &Span { pub fn span(&self) -> &Span {
match self { match self {
Self::Single(_, span) => span, Self::Single(_, span, _) => span,
Self::Tuple(tuple) => &tuple.span, Self::Tuple(tuple) => &tuple.span,
} }
} }
pub fn id(&self) -> &NodeID {
match self {
Self::Single(_, _, id) => id,
Self::Tuple(tuple) => &tuple.id,
}
}
pub fn set_id(&mut self, id: NodeID) {
match self {
Self::Single(_, _, old_id) => *old_id = id,
Self::Tuple(tuple) => tuple.id = id,
}
}
} }
impl fmt::Display for GroupLiteral { impl fmt::Display for GroupLiteral {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self { match self {
Self::Single(string, _) => write!(f, "{string}"), Self::Single(string, _, _) => write!(f, "{string}"),
Self::Tuple(tuple) => write!(f, "{}", tuple.x), // Temporarily emit x coordinate only. Self::Tuple(tuple) => write!(f, "{}", tuple.x), // Temporarily emit x coordinate only.
} }
} }
@ -63,4 +78,6 @@ pub struct GroupTuple {
pub y: GroupCoordinate, pub y: GroupCoordinate,
/// The span from `(` to `)`. /// The span from `(` to `)`.
pub span: Span, pub span: Span,
/// The ID of the node.
pub id: NodeID,
} }

8
compiler/ast/src/input/input_value.rs
View File

@ -35,11 +35,11 @@ impl TryFrom<(Type, Expression)> for InputValue {
fn try_from(value: (Type, Expression)) -> Result<Self> { fn try_from(value: (Type, Expression)) -> Result<Self> {
Ok(match value { Ok(match value {
(type_, Expression::Literal(lit)) => match (type_, lit) { (type_, Expression::Literal(lit)) => match (type_, lit) {
(Type::Address, Literal::Address(value, _)) => Self::Address(value), (Type::Address, Literal::Address(value, _, _)) => Self::Address(value),
(Type::Boolean, Literal::Boolean(value, _)) => Self::Boolean(value), (Type::Boolean, Literal::Boolean(value, _, _)) => Self::Boolean(value),
(Type::Field, Literal::Field(value, _)) => Self::Field(value), (Type::Field, Literal::Field(value, _, _)) => Self::Field(value),
(Type::Group, Literal::Group(value)) => Self::Group(*value), (Type::Group, Literal::Group(value)) => Self::Group(*value),
(Type::Integer(expected), Literal::Integer(actual, value, span)) => { (Type::Integer(expected), Literal::Integer(actual, value, span, _)) => {
if expected == actual { if expected == actual {
Self::Integer(expected, value) Self::Integer(expected, value)
} else { } else {

44
compiler/ast/src/value/mod.rs
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>. // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::{GroupLiteral, Identifier, IntegerType, Literal, Type}; use crate::{GroupLiteral, Identifier, IntegerType, Literal, NodeID, Type};
use leo_errors::{type_name, FlattenError, LeoError, Result}; use leo_errors::{type_name, FlattenError, LeoError, Result};
use leo_span::{Span, Symbol}; use leo_span::{Span, Symbol};
@ -871,13 +871,13 @@ impl TryFrom<&Literal> for Value {
/// Converts a literal to a value. /// Converts a literal to a value.
fn try_from(literal: &Literal) -> Result<Self, Self::Error> { fn try_from(literal: &Literal) -> Result<Self, Self::Error> {
Ok(match literal { Ok(match literal {
Literal::Address(string, span) => Self::Address(string.clone(), *span), Literal::Address(string, span, _) => Self::Address(string.clone(), *span),
Literal::Boolean(bool, span) => Self::Boolean(*bool, *span), Literal::Boolean(bool, span, _) => Self::Boolean(*bool, *span),
Literal::Field(string, span) => Self::Field(string.clone(), *span), Literal::Field(string, span, _) => Self::Field(string.clone(), *span),
Literal::Group(group_literal) => Self::Group(group_literal.clone()), Literal::Group(group_literal) => Self::Group(group_literal.clone()),
Literal::Scalar(string, span) => Self::Scalar(string.clone(), *span), Literal::Scalar(string, span, _) => Self::Scalar(string.clone(), *span),
Literal::String(string, span) => Self::String(string.clone(), *span), Literal::String(string, span, _) => Self::String(string.clone(), *span),
Literal::Integer(integer_type, string, span) => match integer_type { Literal::Integer(integer_type, string, span, _) => match integer_type {
IntegerType::U8 => Self::U8(string.parse()?, *span), IntegerType::U8 => Self::U8(string.parse()?, *span),
IntegerType::U16 => Self::U16(string.parse()?, *span), IntegerType::U16 => Self::U16(string.parse()?, *span),
IntegerType::U32 => Self::U32(string.parse()?, *span), IntegerType::U32 => Self::U32(string.parse()?, *span),
@ -898,23 +898,23 @@ impl From<Value> for Literal {
use Value::*; use Value::*;
match v { match v {
Input(_, _) => todo!("We need to test if this is hittable"), Input(_, _) => todo!("We need to test if this is hittable"),
Address(v, span) => Literal::Address(v, span), Address(v, span) => Literal::Address(v, span, NodeID::default()),
Boolean(v, span) => Literal::Boolean(v, span), Boolean(v, span) => Literal::Boolean(v, span, NodeID::default()),
Struct(_ident, _values) => todo!("We need to test if this is hittable"), Struct(_ident, _values) => todo!("We need to test if this is hittable"),
Field(v, span) => Literal::Field(v, span), Field(v, span) => Literal::Field(v, span, NodeID::default()),
Group(v) => Literal::Group(v), Group(v) => Literal::Group(v),
I8(v, span) => Literal::Integer(IntegerType::I8, v.to_string(), span), I8(v, span) => Literal::Integer(IntegerType::I8, v.to_string(), span, NodeID::default()),
I16(v, span) => Literal::Integer(IntegerType::I16, v.to_string(), span), I16(v, span) => Literal::Integer(IntegerType::I16, v.to_string(), span, NodeID::default()),
I32(v, span) => Literal::Integer(IntegerType::I32, v.to_string(), span), I32(v, span) => Literal::Integer(IntegerType::I32, v.to_string(), span, NodeID::default()),
I64(v, span) => Literal::Integer(IntegerType::I64, v.to_string(), span), I64(v, span) => Literal::Integer(IntegerType::I64, v.to_string(), span, NodeID::default()),
I128(v, span) => Literal::Integer(IntegerType::I128, v.to_string(), span), I128(v, span) => Literal::Integer(IntegerType::I128, v.to_string(), span, NodeID::default()),
U8(v, span) => Literal::Integer(IntegerType::U8, v.to_string(), span), U8(v, span) => Literal::Integer(IntegerType::U8, v.to_string(), span, NodeID::default()),
U16(v, span) => Literal::Integer(IntegerType::U16, v.to_string(), span), U16(v, span) => Literal::Integer(IntegerType::U16, v.to_string(), span, NodeID::default()),
U32(v, span) => Literal::Integer(IntegerType::U32, v.to_string(), span), U32(v, span) => Literal::Integer(IntegerType::U32, v.to_string(), span, NodeID::default()),
U64(v, span) => Literal::Integer(IntegerType::U64, v.to_string(), span), U64(v, span) => Literal::Integer(IntegerType::U64, v.to_string(), span, NodeID::default()),
U128(v, span) => Literal::Integer(IntegerType::U128, v.to_string(), span), U128(v, span) => Literal::Integer(IntegerType::U128, v.to_string(), span, NodeID::default()),
Scalar(v, span) => Literal::Scalar(v, span), Scalar(v, span) => Literal::Scalar(v, span, NodeID::default()),
String(v, span) => Literal::String(v, span), String(v, span) => Literal::String(v, span, NodeID::default()),
} }
} }
} }