leo_ast/types/
type_.rs

1// Copyright (C) 2019-2025 Provable Inc.
2// This file is part of the Leo library.
3
4// The Leo library is free software: you can redistribute it and/or modify
5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
8
9// The Leo library is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12// GNU General Public License for more details.
13
14// You should have received a copy of the GNU General Public License
15// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
16
17use crate::{ArrayType, CompositeType, FutureType, Identifier, IntegerType, MappingType, TupleType, common};
18
19use itertools::Itertools;
20use leo_span::Symbol;
21use serde::{Deserialize, Serialize};
22use snarkvm::prelude::{
23    Network,
24    PlaintextType,
25    PlaintextType::{Array, Literal, Struct},
26};
27use std::fmt;
28
29/// Explicit type used for defining a variable or expression type
30#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
31pub enum Type {
32    /// The `address` type.
33    Address,
34    /// The array type.
35    Array(ArrayType),
36    /// The `bool` type.
37    Boolean,
38    /// The `struct` type.
39    Composite(CompositeType),
40    /// The `field` type.
41    Field,
42    /// The `future` type.
43    Future(FutureType),
44    /// The `group` type.
45    Group,
46    /// A reference to a built in type.
47    Identifier(Identifier),
48    /// An integer type.
49    Integer(IntegerType),
50    /// A mapping type.
51    Mapping(MappingType),
52    /// The `scalar` type.
53    Scalar,
54    /// The `signature` type.
55    Signature,
56    /// The `string` type.
57    String,
58    /// A static tuple of at least one type.
59    Tuple(TupleType),
60    /// Numeric type which should be resolved to `Field`, `Group`, `Integer(_)`, or `Scalar`.
61    Numeric,
62    /// The `unit` type.
63    Unit,
64    /// Placeholder for a type that could not be resolved or was not well-formed.
65    /// Will eventually lead to a compile error.
66    #[default]
67    Err,
68}
69
70impl Type {
71    /// Returns `true` if the self `Type` is equal to the other `Type` in all aspects besides composite program of origin.
72    ///
73    /// In the case of futures, it also makes sure that if both are not explicit, they are equal.
74    ///
75    /// Flattens array syntax: `[[u8; 1]; 2] == [u8; (2, 1)] == true`
76    ///
77    pub fn eq_flat_relaxed(&self, other: &Self) -> bool {
78        match (self, other) {
79            (Type::Address, Type::Address)
80            | (Type::Boolean, Type::Boolean)
81            | (Type::Field, Type::Field)
82            | (Type::Group, Type::Group)
83            | (Type::Scalar, Type::Scalar)
84            | (Type::Signature, Type::Signature)
85            | (Type::String, Type::String)
86            | (Type::Unit, Type::Unit) => true,
87            (Type::Array(left), Type::Array(right)) => {
88                left.element_type().eq_flat_relaxed(right.element_type()) && left.length() == right.length()
89            }
90            (Type::Identifier(left), Type::Identifier(right)) => left.matches(right),
91            (Type::Integer(left), Type::Integer(right)) => left.eq(right),
92            (Type::Mapping(left), Type::Mapping(right)) => {
93                left.key.eq_flat_relaxed(&right.key) && left.value.eq_flat_relaxed(&right.value)
94            }
95            (Type::Tuple(left), Type::Tuple(right)) if left.length() == right.length() => left
96                .elements()
97                .iter()
98                .zip_eq(right.elements().iter())
99                .all(|(left_type, right_type)| left_type.eq_flat_relaxed(right_type)),
100            (Type::Composite(left), Type::Composite(right)) => left.id.name == right.id.name,
101            // Don't type check when type hasn't been explicitly defined.
102            (Type::Future(left), Type::Future(right)) if !left.is_explicit || !right.is_explicit => true,
103            (Type::Future(left), Type::Future(right)) if left.inputs.len() == right.inputs.len() => left
104                .inputs()
105                .iter()
106                .zip_eq(right.inputs().iter())
107                .all(|(left_type, right_type)| left_type.eq_flat_relaxed(right_type)),
108            _ => false,
109        }
110    }
111
112    pub fn from_snarkvm<N: Network>(t: &PlaintextType<N>, program: Option<Symbol>) -> Self {
113        match t {
114            Literal(lit) => match lit {
115                snarkvm::prelude::LiteralType::Address => Type::Address,
116                snarkvm::prelude::LiteralType::Boolean => Type::Boolean,
117                snarkvm::prelude::LiteralType::Field => Type::Field,
118                snarkvm::prelude::LiteralType::Group => Type::Group,
119                snarkvm::prelude::LiteralType::U8 => Type::Integer(IntegerType::U8),
120                snarkvm::prelude::LiteralType::U16 => Type::Integer(IntegerType::U16),
121                snarkvm::prelude::LiteralType::U32 => Type::Integer(IntegerType::U32),
122                snarkvm::prelude::LiteralType::U64 => Type::Integer(IntegerType::U64),
123                snarkvm::prelude::LiteralType::U128 => Type::Integer(IntegerType::U128),
124                snarkvm::prelude::LiteralType::I8 => Type::Integer(IntegerType::I8),
125                snarkvm::prelude::LiteralType::I16 => Type::Integer(IntegerType::I16),
126                snarkvm::prelude::LiteralType::I32 => Type::Integer(IntegerType::I32),
127                snarkvm::prelude::LiteralType::I64 => Type::Integer(IntegerType::I64),
128                snarkvm::prelude::LiteralType::I128 => Type::Integer(IntegerType::I128),
129                snarkvm::prelude::LiteralType::Scalar => Type::Scalar,
130                snarkvm::prelude::LiteralType::Signature => Type::Signature,
131                snarkvm::prelude::LiteralType::String => Type::String,
132            },
133            Struct(s) => Type::Composite(CompositeType { id: common::Identifier::from(s), program }),
134            Array(array) => Type::Array(ArrayType::from_snarkvm(array, program)),
135        }
136    }
137}
138
139impl fmt::Display for Type {
140    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
141        match *self {
142            Type::Address => write!(f, "address"),
143            Type::Array(ref array_type) => write!(f, "{array_type}"),
144            Type::Boolean => write!(f, "bool"),
145            Type::Field => write!(f, "field"),
146            Type::Future(ref future_type) => write!(f, "{future_type}"),
147            Type::Group => write!(f, "group"),
148            Type::Identifier(ref variable) => write!(f, "{variable}"),
149            Type::Integer(ref integer_type) => write!(f, "{integer_type}"),
150            Type::Mapping(ref mapping_type) => write!(f, "{mapping_type}"),
151            Type::Scalar => write!(f, "scalar"),
152            Type::Signature => write!(f, "signature"),
153            Type::String => write!(f, "string"),
154            Type::Composite(ref struct_type) => write!(f, "{struct_type}"),
155            Type::Tuple(ref tuple) => write!(f, "{tuple}"),
156            Type::Numeric => write!(f, "numeric"),
157            Type::Unit => write!(f, "()"),
158            Type::Err => write!(f, "error"),
159        }
160    }
161}
leo_ast/types/type_.rs

leo_ast/types/
type_.rs
