leo-ast 4.1.0

Abstract syntax tree (AST) for the Leo programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

// Copyright (C) 2019-2026 Provable Inc.
// This file is part of the Leo library.

// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

use super::*;

use itertools::Itertools as _;

/// A dynamic operation against an interface at a runtime target address.
///
/// Covers three surface forms:
///
/// - **Function call** (`DynamicOpKind::Call`):
///   `Interface@(target[, network])::func(args)` — invokes an interface function.
///
/// - **Bare storage read** (`DynamicOpKind::Read`):
///   `Interface@(target[, network])::name` — reads a singleton storage variable
///   declared in the interface, producing `Option<T>`.
///
/// - **Storage member operation** (`DynamicOpKind::Op`):
///   `Interface@(target[, network])::member.op(args)` — performs an operation on
///   a mapping (`get`, `get_or_use`, `contains`) or vector (`get`, `len`) storage
///   variable declared in the interface.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DynamicOpExpression {
    /// The interface type.
    pub interface: Type,
    /// The target program expression (`field` or `identifier`).
    pub target_program: Expression,
    /// The optional network expression; defaults to `'aleo'` when `None`.
    pub network: Option<Expression>,
    /// Which dynamic operation this expression represents.
    pub kind: DynamicOpKind,
    /// The span of the entire expression.
    pub span: Span,
    /// The ID of the node.
    pub id: NodeID,
}

/// Distinguishes the three surface forms of [`DynamicOpExpression`].
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum DynamicOpKind {
    /// `Interface@(p)::func(args)` — call a function declared in the interface.
    Call { function: Identifier, arguments: Vec<Expression> },
    /// `Interface@(p)::name` — bare read of a singleton storage variable.
    Read { storage: Identifier },
    /// `Interface@(p)::member.op(args)` — op on a mapping or vector storage variable.
    ///
    /// Mappings support `get`, `get_or_use`, `contains`. Vectors support `get`, `len`.
    Op { member: Identifier, op: Identifier, arguments: Vec<Expression> },
}

impl fmt::Display for DynamicOpExpression {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let target = if let Some(network) = &self.network {
            format!("({}, {})", self.target_program, network)
        } else {
            format!("({})", self.target_program)
        };

        match &self.kind {
            DynamicOpKind::Call { function, arguments } => {
                write!(f, "{}@{}::{}({})", self.interface, target, function, arguments.iter().format(", "))
            }
            DynamicOpKind::Read { storage } => {
                write!(f, "{}@{}::{}", self.interface, target, storage)
            }
            DynamicOpKind::Op { member, op, arguments } => {
                write!(f, "{}@{}::{}.{}({})", self.interface, target, member, op, arguments.iter().format(", "))
            }
        }
    }
}

impl From<DynamicOpExpression> for Expression {
    fn from(value: DynamicOpExpression) -> Self {
        Expression::DynamicOp(Box::new(value))
    }
}

crate::simple_node_impl!(DynamicOpExpression);